@keyou007/agent-bot 0.1.13-alpha.0 → 0.1.13-alpha.2

package/src/feishu/CardRenderer.ts

@@ -139,9 +139,34 @@ export interface TaskListCardAction {
   value: Record<string, string>;
 }
 
+export interface HelpCardCommand {
+  text: string;
+  action?: TaskListCardAction;
+  usage?: string;
+  description: string;
+}
+
+export interface HelpCardSection {
+  title: string;
+  commands: HelpCardCommand[];
+}
+
 export interface TaskListCardEntry {
   lines: string[];
   actions?: TaskListCardAction[];
+  current?: boolean;
+}
+
+export interface ResetHistoryCardEntry extends TaskListCardEntry {
+  sequence: number;
+  graphNodeLine: string;
+  graphConnectorLine?: string;
+}
+
+export interface ResetHistoryCardView {
+  entries: ResetHistoryCardEntry[];
+  footerLines: string[];
+  pageActions: TaskListCardAction[];
 }
 
 export class CardRenderer {
@@ -662,6 +687,18 @@ export class CardRenderer {
         type: "danger",
         value: { action: "turn_cancel", sessionId: state.sessionId, turnId: state.turnId },
       }]));
+    } else if (state.status === "completed") {
+      elements.push(
+        { tag: "hr" },
+        taskActionRow([{
+          text: "Reset",
+          value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
+        }]),
+        {
+          ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到本轮完成时；不会回退本地文件。</font>"),
+          text_size: "notation",
+        },
+      );
     }
     return turnCard(
       turnTitle(state.status, state.prompt ?? state.taskTitle),
@@ -769,12 +806,25 @@ export class CardRenderer {
     return sectionCard(title, elements);
   }
 
+  renderHelpCard(
+    title: string,
+    introLines: string[],
+    sections: HelpCardSection[],
+  ): Record<string, unknown> {
+    const elements: Record<string, unknown>[] = [markdown(introLines.join("\n"))];
+    for (const section of sections) {
+      elements.push({ tag: "hr" }, markdown(`**${section.title}**`));
+      elements.push(...section.commands.map(helpCommandRow));
+    }
+    return sectionCard(title, elements);
+  }
+
   renderTaskListCard(
     title: string,
     sectionTitle: string,
     entries: TaskListCardEntry[],
     footerLines: string[],
-    footerAction?: TaskListCardAction,
+    footerActions: TaskListCardAction[] = [],
   ): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [markdown(`**${sectionTitle}**`)];
     if (entries.length === 0) {
@@ -788,30 +838,12 @@ export class CardRenderer {
         if (index < entries.length - 1) elements.push({ tag: "hr" });
       });
     }
+    if (footerActions.length > 0) {
+      elements.push({ tag: "hr" }, taskActionRow(footerActions));
+    }
     if (footerLines.length > 0) {
       elements.push({ tag: "hr" }, markdown(footerLines.join("\n")));
     }
-    if (footerAction) {
-      elements.push({
-        tag: "column_set",
-        flex_mode: "none",
-        columns: [{
-          tag: "column",
-          width: "weighted",
-          weight: 1,
-          elements: [{
-            tag: "button",
-            text: { tag: "plain_text", content: footerAction.text },
-            type: footerAction.type ?? "default",
-            width: "fill",
-            behaviors: [{
-              type: "callback",
-              value: footerAction.value,
-            }],
-          }],
-        }],
-      });
-    }
     return {
       schema: "2.0",
       config: {
@@ -831,6 +863,39 @@ export class CardRenderer {
     };
   }
 
+  renderResetHistoryCard(view: ResetHistoryCardView): Record<string, unknown> {
+    const elements: Record<string, unknown>[] = [
+      {
+        ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到所选轮次完成时；不会回退本地文件。</font>"),
+        text_size: "notation",
+      },
+      { tag: "hr" },
+      markdown("**历史对话轮次**"),
+    ];
+    if (view.entries.length === 0) {
+      elements.push(markdown("当前任务还没有成功完成的 turn。"));
+    } else {
+      view.entries.forEach((entry) => {
+        const action = entry.actions?.[0];
+        elements.push(resetHistoryEntryRow(
+          entry.graphNodeLine,
+          entry.graphConnectorLine,
+          entry.lines,
+          action,
+          entry.current === true,
+        ));
+      });
+    }
+    if (view.footerLines.length > 0) {
+      elements.push({ tag: "hr" }, {
+        ...markdown(view.footerLines.join("\n")),
+        text_size: "notation",
+      });
+    }
+    if (view.pageActions.length > 0) elements.push(taskActionRow(view.pageActions));
+    return sectionCard("历史对话轮次", elements);
+  }
+
   private baseCard(title: string, template: string, elements: unknown[]): Record<string, unknown> {
     return {
       config: {
@@ -1470,6 +1535,55 @@ function settingsOptionRow(input: {
   };
 }
 
+function resetHistoryEntryRow(
+  graphNodeLine: string,
+  graphConnectorLine: string | undefined,
+  lines: string[],
+  action: TaskListCardAction | undefined,
+  current: boolean,
+): Record<string, unknown> {
+  const graph = [
+    `<font color='${current ? "green" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
+    ...(graphConnectorLine
+      ? [`<font color='grey'>${escapeCardHtml(graphConnectorLine)}</font>`]
+      : []),
+  ].join("\n");
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "12px",
+    vertical_align: "top",
+    columns: [
+      {
+        tag: "column",
+        width: "auto",
+        vertical_align: "top",
+        elements: [{
+          ...markdown(graph),
+          text_align: "center",
+        }],
+      },
+      {
+        tag: "column",
+        width: "weighted",
+        weight: 1,
+        vertical_align: "top",
+        elements: [markdown(lines.join("\n"))],
+      },
+      {
+        tag: "column",
+        width: "auto",
+        vertical_align: "top",
+        elements: current
+          ? [markdown("✅ 当前")]
+          : action
+            ? [taskActionElement(action)]
+            : [],
+      },
+    ],
+  };
+}
+
 function taskActionRow(actions: TaskListCardAction[]): Record<string, unknown> {
   return {
     tag: "column_set",
@@ -1501,6 +1615,39 @@ function taskActionElement(action: TaskListCardAction): Record<string, unknown>
   };
 }
 
+function helpCommandRow(command: HelpCardCommand): Record<string, unknown> {
+  const details = [
+    command.usage ? `**${command.usage}**` : undefined,
+    command.description,
+  ].filter((line): line is string => Boolean(line)).join("　");
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "12px",
+    vertical_align: "top",
+    margin: "2px 0 0 0",
+    columns: [
+      {
+        tag: "column",
+        width: "auto",
+        vertical_align: "top",
+        elements: [
+          command.action
+            ? taskActionElement(command.action)
+            : markdown(`**${escapeCardHtml(command.text)}**`),
+        ],
+      },
+      {
+        tag: "column",
+        width: "weighted",
+        weight: 1,
+        vertical_align: "top",
+        elements: [markdown(details)],
+      },
+    ],
+  };
+}
+
 function turnCard(
   title: string,
   template: string,

package/src/feishu/FeishuConnector.ts

@@ -5,6 +5,7 @@ import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
 import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
 type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
+type BotOpenIdListener = (botOpenId: string) => void;
 
 export class FeishuConnector {
   constructor(
@@ -12,6 +13,7 @@ export class FeishuConnector {
     private readonly handler: FeishuEventHandler,
     private readonly logger: Logger,
     private readonly botOpenIdResolver: BotOpenIdResolver = resolveFeishuBotOpenId,
+    private readonly onBotOpenId?: BotOpenIdListener,
   ) {}
 
   async start(): Promise<void> {
@@ -21,10 +23,17 @@ export class FeishuConnector {
     }
 
     const respondToAllGroupMessages = this.config.feishu.respondToAllGroupMessages !== false;
-    const botOpenId = respondToAllGroupMessages
-      ? undefined
-      : await this.botOpenIdResolver(appId, appSecret);
-    await this.startFeishuWs(appId, appSecret, botOpenId);
+    let botOpenId: string | undefined;
+    if (!respondToAllGroupMessages || this.onBotOpenId) {
+      try {
+        botOpenId = await this.botOpenIdResolver(appId, appSecret);
+        this.onBotOpenId?.(botOpenId);
+      } catch (error) {
+        if (!respondToAllGroupMessages) throw error;
+        this.logger.warn({ error }, "Failed to resolve the Lark bot Open ID for the Agent environment.");
+      }
+    }
+    await this.startFeishuWs(appId, appSecret, respondToAllGroupMessages ? undefined : botOpenId);
   }
 
   stop(): void {

package/src/index.ts

@@ -5,6 +5,13 @@ import { LocalControlServer } from "./cli/LocalControlServer.js";
 import { controlEndpoint, type ControlRequest, type ControlResponse } from "./cli/controlProtocol.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
 import { loadConfig } from "./config/loadConfig.js";
+import { persistFeishuUserOpenIdIfMissing } from "./config/FeishuUserOpenIdStore.js";
+import {
+  agentBotHome,
+  defaultConfigPath,
+  defaultDotEnvPath,
+  resolveUserPath,
+} from "./config/paths.js";
 import { ConsoleConnector } from "./console/ConsoleConnector.js";
 import { ConsoleTurnPresenter } from "./console/ConsoleTurnPresenter.js";
 import { CardRenderer } from "./feishu/CardRenderer.js";
@@ -12,18 +19,26 @@ import { ConsoleFeishuClient } from "./feishu/ConsoleFeishuClient.js";
 import { FeishuConnector } from "./feishu/FeishuConnector.js";
 import { FeishuMessageClient } from "./feishu/FeishuMessageClient.js";
 import { FeishuTurnPresenter } from "./feishu/FeishuTurnPresenter.js";
+import { baseChatContextKey, isThreadContextKey } from "./feishu/contextKey.js";
+import type { MessageReplyTarget } from "./feishu/types.js";
 import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { createLogger } from "./logging/logger.js";
 import { OutboundRouter, type OutboundRoute } from "./presentation/OutboundRouter.js";
 import { ProxySessionController } from "./proxy/ProxySessionController.js";
+import type { AgentEnvironmentContext } from "./runtime/agentEnvironment.js";
 import { createAgentRuntimeRegistry } from "./runtime/createAgentRuntimeRegistry.js";
 import { StateStore } from "./state/StateStore.js";
 import { StartupNotifier } from "./startup/StartupNotifier.js";
 import { SessionMetadataHydrator } from "./startup/SessionMetadataHydrator.js";
 import { startFeishu } from "./startup/startFeishu.js";
 import { STOP_EXIT_CODE } from "./supervision/restartPolicy.js";
-import { replacementSupervisorEnvironment } from "./supervision/replacementSupervisor.js";
+import {
+  RESTART_GROUP_CONTEXTS_ENV,
+  replacementSupervisorEnvironment,
+  restartGroupContextKeysFromEnvironment,
+} from "./supervision/replacementSupervisor.js";
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
+import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
 import { SafeRestartNotifier } from "./supervision/SafeRestartNotifier.js";
 import {
   nodeDiagnosticReportArguments,
@@ -37,13 +52,23 @@ const agentBotVersion = readPackageVersion();
 const supervised = process.env.AGENT_BOT_SUPERVISED === "1";
 const startupReason = process.env.AGENT_BOT_RESTART_REASON?.trim()
   || (supervised ? "Supervisor 启动" : "直接启动");
+const restartGroupContextKeys = restartGroupContextKeysFromEnvironment(
+  process.env[RESTART_GROUP_CONTEXTS_ENV],
+);
 const consoleOnly = process.env.AGENT_BOT_CONSOLE_ONLY === "1";
 const config = loadConfig();
 const transport = consoleOnly ? "console" : requireServerFeishuTransport(config.feishu);
 const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
 
-const runtimes = createAgentRuntimeRegistry(config, logger);
+const configuredConfigPath = process.env.AGENT_BOT_CONFIG?.trim();
+const agentEnvironmentContext: AgentEnvironmentContext = {
+  profilePath: agentBotHome(),
+  configPath: configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath(),
+  larkAppId: config.feishu.appId,
+  larkUserOpenId: config.feishu.userOpenId,
+};
+const runtimes = createAgentRuntimeRegistry(config, logger, agentEnvironmentContext);
 
 const routes: OutboundRoute[] = [];
 let feishuConnector: FeishuConnector | undefined;
@@ -92,7 +117,7 @@ let shuttingDown = false;
 let restartRequested = false;
 const safeRestart = new SafeRestartScheduler({
   readActivity: () => store.getServerActivityState(),
-  onReady: (reason) => initiateRestart(reason),
+  onReady: (reason, notificationTargets) => initiateRestart(reason, notificationTargets),
   onStatus: (status) => safeRestartNotifier?.update(status),
   onStatusError: (error) => logger.warn({ error }, "Failed to publish safe restart status."),
 });
@@ -100,9 +125,28 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
   supervised,
   restart: requestRestart,
   cancelSafeRestart: (scheduleId) => safeRestart.cancelScheduled(scheduleId),
+  rememberFeishuUserOpenId: (userOpenId) => {
+    if (config.feishu.userOpenId?.startsWith("ou_")) return;
+    const persisted = persistFeishuUserOpenIdIfMissing(defaultDotEnvPath(), userOpenId);
+    config.feishu.userOpenId = persisted.userOpenId;
+    agentEnvironmentContext.larkUserOpenId = persisted.userOpenId;
+    process.env.FEISHU_USER_OPEN_ID = persisted.userOpenId;
+    logger.info(
+      { status: persisted.status },
+      "Stored the default Lark user Open ID from the first private chat message.",
+    );
+  },
 });
 
-if (feishuOutbound) feishuConnector = new FeishuConnector(config, controller, logger);
+if (feishuOutbound) {
+  feishuConnector = new FeishuConnector(
+    config,
+    controller,
+    logger,
+    undefined,
+    (botOpenId) => { agentEnvironmentContext.larkBotOpenId = botOpenId; },
+  );
+}
 if (consoleEnabled) consoleConnector = new ConsoleConnector(controller, logger);
 
 process.on("SIGINT", () => void shutdown(0));
@@ -126,6 +170,7 @@ if (feishuConnector && startupNotifier) {
     startupReason,
     startControlServer,
     () => { serverReady = true; },
+    restartGroupContextKeys,
   );
 } else {
   await startControlServer();
@@ -134,40 +179,59 @@ if (feishuConnector && startupNotifier) {
 }
 consoleConnector?.start();
 
-async function requestRestart(contextKey: string, force: boolean): Promise<void> {
+async function requestRestart(
+  contextKey: string,
+  force: boolean,
+  replyTarget?: MessageReplyTarget,
+): Promise<void> {
+  const notificationTarget: RestartNotificationTarget = {
+    contextKey,
+    ...(replyTarget ? { replyMessageId: replyTarget.messageId } : {}),
+  };
   if (restartRequested) {
     await outbound.sendText(contextKey, "Agent Bot 已在重启中，请稍候。").catch(() => undefined);
     return;
   }
   if (force) {
-    await initiateRestart("用户执行 /restart --force 命令", contextKey);
+    await initiateRestart("用户执行 /restart --force 命令", [notificationTarget]);
     return;
   }
-  const newlyScheduled = safeRestart.schedule("用户执行 /restart 命令");
+  const newlyScheduled = safeRestart.schedule("用户执行 /restart 命令", notificationTarget);
   await outbound.sendText(
     contextKey,
     newlyScheduled
       ? "已安排安全重启。Agent Bot 会等待所有任务完成、最终结果投递完成，并保持 15 秒无新消息后重启。"
-      : "安全重启已在等待中，已更新重启原因。",
+      : "安全重启已在等待中；当前会话已加入通知范围，并已更新重启原因。",
   ).catch((error: unknown) => {
     logger.warn({ error, contextKey }, "Failed to send safe restart acknowledgement.");
   });
 }
 
-async function initiateRestart(reason: string, contextKey?: string): Promise<void> {
+async function initiateRestart(
+  reason: string,
+  notificationTargets: RestartNotificationTarget[] = [],
+): Promise<void> {
   if (restartRequested) {
-    if (contextKey) await outbound.sendText(contextKey, "Agent Bot 已在重启中，请稍候。").catch(() => undefined);
+    await sendRestartTexts(notificationTargets, "Agent Bot 已在重启中，请稍候。");
     return;
   }
   restartRequested = true;
   await safeRestart.cancelCurrent();
   await safeRestartNotifier?.flush();
-  if (contextKey) {
-    await outbound.sendText(contextKey, "Agent Bot 正在重启，恢复在线后会发送启动状态通知。").catch((error: unknown) => {
-      logger.warn({ error, contextKey }, "Failed to send restart acknowledgement.");
-    });
-  }
-  setTimeout(() => void shutdown(supervised ? STOP_EXIT_CODE : 0, reason), 100);
+  const allNotificationTargets = mergeRestartNotificationTargets(
+    notificationTargets,
+    safeRestartNotifier?.getNotificationTargets() ?? [],
+  );
+  const restartGroupContextKeys = groupContextKeysForRestartTargets(allNotificationTargets);
+  await sendRestartTexts(
+    allNotificationTargets,
+    "Agent Bot 正在重启，恢复在线后会发送启动状态通知。",
+  );
+  setTimeout(() => void shutdown(
+    supervised ? STOP_EXIT_CODE : 0,
+    reason,
+    restartGroupContextKeys,
+  ), 100);
 }
 
 async function handleControlRequest(request: ControlRequest): Promise<ControlResponse> {
@@ -182,14 +246,25 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           startedAt: processStartedAt.toISOString(),
           supervised,
           feishuAppId: config.feishu.appId ?? null,
+          agents: runtimes.entries().map(([name, runtime]) => {
+            const processInfo = runtime.getProcessInfo?.() ?? {};
+            return {
+              name,
+              title: config.agents[name]?.title ?? name,
+              kind: config.agents[name]?.kind ?? runtime.kind,
+              pid: processInfo.pid ?? null,
+              version: processInfo.version ?? null,
+            };
+          }),
           safeRestartScheduled: safeRestart.scheduled,
           safeRestartReason: safeRestart.pendingReason,
           activity: store.getServerActivityState(),
         },
       };
-    case "server_restart":
+    case "server_restart": {
+      const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
       if (request.mode === "safe") {
-        const newlyScheduled = safeRestart.schedule(request.reason);
+        const newlyScheduled = safeRestart.schedule(request.reason, notificationTarget);
         return {
           ok: true,
           message: newlyScheduled
@@ -197,8 +272,12 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
             : "A safe restart is already pending. Its reason has been updated.",
         };
       }
-      setTimeout(() => void initiateRestart(request.reason), 25);
+      setTimeout(() => void initiateRestart(
+        request.reason,
+        notificationTarget ? [notificationTarget] : [],
+      ), 25);
       return { ok: true, message: "Immediate restart requested." };
+    }
     case "server_stop":
       safeRestart.cancel();
       setTimeout(() => void shutdown(STOP_EXIT_CODE), 25);
@@ -235,7 +314,11 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
   }
 }
 
-async function shutdown(exitCode: number, restartReason?: string): Promise<void> {
+async function shutdown(
+  exitCode: number,
+  restartReason?: string,
+  restartGroupContextKeys: string[] = [],
+): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   logger.info({ exitCode }, "Shutting down Agent Bot.");
@@ -250,11 +333,11 @@ async function shutdown(exitCode: number, restartReason?: string): Promise<void>
   runtimes.close();
   await controlServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local control endpoint."));
   store.close();
-  if (restartReason) startReplacementSupervisor(restartReason);
+  if (restartReason) startReplacementSupervisor(restartReason, restartGroupContextKeys);
   process.exit(exitCode);
 }
 
-function startReplacementSupervisor(restartReason: string): void {
+function startReplacementSupervisor(restartReason: string, restartGroupContextKeys: string[]): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
   const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
   prepareCrashReportDirectory(reportDirectory);
@@ -275,11 +358,100 @@ function startReplacementSupervisor(restartReason: string): void {
     detached: true,
     windowsHide: true,
     stdio: "ignore",
-    env: replacementSupervisorEnvironment(restartReason, environmentRefresh.environment),
+    env: replacementSupervisorEnvironment(
+      restartReason,
+      environmentRefresh.environment,
+      restartGroupContextKeys,
+    ),
   });
   supervisor.unref();
 }
 
+function inferControlRestartTarget(notificationSessionId?: string): RestartNotificationTarget | undefined {
+  const requestedSessionId = notificationSessionId?.trim();
+  if (requestedSessionId) {
+    const requested = store.getSession(requestedSessionId)
+      ?? store.findSessionByRemoteSessionId(requestedSessionId);
+    if (!requested) throw new Error(`Cannot route restart notifications: unknown task ${requestedSessionId}.`);
+    return restartNotificationTargetForSession(requested);
+  }
+
+  const runningSessions = store.listAllSessions().filter((session) => session.status === "running");
+  const runningContexts = new Set(runningSessions.map((session) => session.contextKey));
+  if (runningContexts.size > 1) {
+    throw new Error(
+      "Cannot determine which conversation requested the restart because multiple conversations are running. Pass --task <task>.",
+    );
+  }
+  const contextKey = runningContexts.size === 1 ? runningContexts.values().next().value : undefined;
+  const session = contextKey
+    ? runningSessions.find((candidate) => candidate.contextKey === contextKey)
+    : undefined;
+  return session ? restartNotificationTargetForSession(session) : undefined;
+}
+
+function restartNotificationTargetForSession(
+  session: { localSessionId: string; contextKey: string },
+): RestartNotificationTarget {
+  const replyMessageId = isThreadContextKey(session.contextKey)
+    ? store.findLatestMessageIdForSession(session.localSessionId, session.contextKey)
+      ?? store.findLatestMessageIdForContext(session.contextKey)
+    : undefined;
+  if (isThreadContextKey(session.contextKey) && !replyMessageId) {
+    throw new Error(
+      "Cannot route restart notifications to the task topic because it has no message anchor. Send /restart in that topic instead.",
+    );
+  }
+  return {
+    contextKey: session.contextKey,
+    ...(replyMessageId ? { replyMessageId } : {}),
+  };
+}
+
+async function sendRestartText(target: RestartNotificationTarget, text: string): Promise<string | undefined> {
+  if (isThreadContextKey(target.contextKey) && !target.replyMessageId) {
+    throw new Error("Cannot send a restart notice to a topic without a reply message anchor.");
+  }
+  const replyTarget = target.replyMessageId
+    ? { messageId: target.replyMessageId, replyInThread: true as const }
+    : undefined;
+  return outbound.withReplyTarget(target.contextKey, replyTarget, () =>
+    outbound.sendText(target.contextKey, text));
+}
+
+async function sendRestartTexts(targets: RestartNotificationTarget[], text: string): Promise<void> {
+  await Promise.all(targets.map(async (target) => {
+    await sendRestartText(target, text).catch((error: unknown) => {
+      logger.warn(
+        { error, contextKey: target.contextKey },
+        "Failed to send restart acknowledgement.",
+      );
+    });
+  }));
+}
+
+function groupContextKeysForRestartTargets(targets: RestartNotificationTarget[]): string[] {
+  const knownGroupContextKeys = new Set(
+    store.listChatContexts("group").map((chat) => chat.contextKey),
+  );
+  return [...new Set(targets
+    .map((target) => baseChatContextKey(target.contextKey))
+    .filter((contextKey) => knownGroupContextKeys.has(contextKey)))];
+}
+
+function mergeRestartNotificationTargets(
+  ...targetGroups: RestartNotificationTarget[][]
+): RestartNotificationTarget[] {
+  const targets = new Map<string, RestartNotificationTarget>();
+  for (const target of targetGroups.flat()) {
+    const existing = targets.get(target.contextKey);
+    if (!existing || (!existing.replyMessageId && target.replyMessageId)) {
+      targets.set(target.contextKey, { ...target });
+    }
+  }
+  return [...targets.values()];
+}
+
 function delay(milliseconds: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }

package/src/presentation/turnGraph.ts

@@ -0,0 +1,48 @@
+export interface TurnGraphNode {
+  turnId: string;
+  parentTurnId?: string;
+}
+
+export interface TurnGraphRow {
+  sequence: number;
+  nodeLine: string;
+  connectorLine?: string;
+}
+
+export function buildTurnGraphRows(nodes: readonly TurnGraphNode[]): TurnGraphRow[] {
+  const visibleTurnIds = new Set(nodes.map((node) => node.turnId));
+  const lanes: string[] = [];
+
+  return nodes.map((node, index) => {
+    let lane = lanes.indexOf(node.turnId);
+    if (lane < 0) {
+      lane = lanes.length;
+      lanes.push(node.turnId);
+    }
+
+    const sequence = index + 1;
+    const nodeLine = `${lanes.map((_, laneIndex) => laneIndex === lane ? "●" : "│").join(" ")} ${sequence}`;
+    const parentTurnId = node.parentTurnId && visibleTurnIds.has(node.parentTurnId)
+      ? node.parentTurnId
+      : undefined;
+    let connectorLine: string | undefined;
+
+    if (!parentTurnId) {
+      lanes.splice(lane, 1);
+      connectorLine = lanes.length > 0 ? lanes.map(() => "│").join(" ") : undefined;
+    } else {
+      const existingParentLane = lanes.indexOf(parentTurnId);
+      if (existingParentLane < 0 || existingParentLane === lane) {
+        lanes[lane] = parentTurnId;
+        connectorLine = lanes.map(() => "│").join(" ");
+      } else {
+        const connectorLanes = lanes.map(() => "│");
+        connectorLanes[lane] = lane > existingParentLane ? "╱" : "╲";
+        connectorLine = connectorLanes.join(" ");
+        lanes.splice(lane, 1);
+      }
+    }
+
+    return { sequence, nodeLine, ...(connectorLine ? { connectorLine } : {}) };
+  });
+}