@keyou007/agent-bot 0.1.12 → 0.1.13-alpha.1

package/src/runtime/AcpRuntimeAdapter.ts

@@ -99,7 +99,9 @@ export class AcpRuntimeAdapter implements AgentRuntime {
 
   async startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string> {
     const { text, localImagePaths } = normalizeRuntimePrompt(prompt);
-    if (localImagePaths.length > 0) throw new Error("当前 ACP Agent 不支持图片输入，请切换到 Codex 后重试。");
+    if (localImagePaths.length > 0) {
+      throw new Error("当前 ACP Agent 不支持图片输入，请切换到支持图片输入的 App Server Agent 后重试。");
+    }
     const session = this.requireSession(sessionId);
     const turnId = createId("turn");
     session.activeTurnId = turnId;

package/src/startup/StartupNotifier.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "pino";
 import { detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
 import { CardRenderer } from "../feishu/CardRenderer.js";
+import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
 import type { FeishuOutbound } from "../feishu/types.js";
 import type { SessionRecord, StateStore, UserContextRecord } from "../state/StateStore.js";
 
@@ -32,15 +33,30 @@ export class StartupNotifier {
     private readonly metadataHydrator?: StartupTaskMetadataHydrator,
   ) {}
 
-  async notify(startedAt: Date, restartReason: string): Promise<void> {
+  async notify(
+    startedAt: Date,
+    restartReason: string,
+    restartGroupContextKeys: string[] = [],
+  ): Promise<void> {
     let targets: StartupNotificationTarget[];
     try {
-      const activeGroupSince = new Date(startedAt.getTime() - 3 * 60 * 1_000);
-      const chats = [
-        ...this.store.listChatContexts("p2p"),
-        ...this.store.listRecentlyActiveChatContexts(activeGroupSince)
-          .filter((chat) => chat.chatType === "group"),
-      ];
+      const activeGroupSince = new Date(startedAt.getTime() - 60_000);
+      const knownGroups = new Map(
+        this.store.listChatContexts("group")
+          .filter((chat) => !isThreadContextKey(chat.contextKey))
+          .map((chat) => [chat.contextKey, chat]),
+      );
+      const targetGroups = new Map(
+        this.store.listRecentlyActiveChatContexts(activeGroupSince)
+          .filter((chat) => chat.chatType === "group" && !isThreadContextKey(chat.contextKey))
+          .map((chat) => [chat.contextKey, chat]),
+      );
+      for (const contextKey of restartGroupContextKeys) {
+        const baseContextKey = baseChatContextKey(contextKey.trim());
+        const group = knownGroups.get(baseContextKey);
+        if (group) targetGroups.set(baseContextKey, group);
+      }
+      const chats = [...this.store.listChatContexts("p2p"), ...targetGroups.values()];
       targets = chats.map((chat) => ({
         contextKey: chat.contextKey,
         context: this.store.getUserContext(chat.contextKey),

package/src/startup/startFeishu.ts

@@ -3,7 +3,7 @@ export interface StartableFeishuConnector {
 }
 
 export interface StartupNotificationSender {
-  notify(startedAt: Date, restartReason: string): Promise<void>;
+  notify(startedAt: Date, restartReason: string, restartGroupContextKeys?: string[]): Promise<void>;
 }
 
 export async function startFeishu(
@@ -13,9 +13,10 @@ export async function startFeishu(
   restartReason: string,
   prepare?: () => Promise<void>,
   onConnected?: () => void,
+  restartGroupContextKeys: string[] = [],
 ): Promise<void> {
   await prepare?.();
   await connector.start();
-  await notifier.notify(startedAt, restartReason);
+  await notifier.notify(startedAt, restartReason, restartGroupContextKeys);
   onConnected?.();
 }

package/src/state/StateStore.ts

@@ -63,6 +63,21 @@ export interface TurnAnchorRecord {
   contextKey?: string;
 }
 
+export interface TurnRuntimeOriginRecord {
+  turnId: string;
+  localSessionId: string;
+  agentName: string;
+  remoteSessionId: string;
+  createdAt: string;
+}
+
+export interface CompletedTurnSnapshotRecord {
+  turnId: string;
+  parentTurnId?: string;
+  snapshot: unknown;
+  updatedAt: string;
+}
+
 export interface QueuedPromptRecord {
   promptId: string;
   localSessionId: string;
@@ -605,6 +620,50 @@ export class StateStore {
     return row ? JSON.parse(row.snapshot_json) : undefined;
   }
 
+  saveTurnRuntimeOrigin(
+    turnId: string,
+    localSessionId: string,
+    agentName: string,
+    remoteSessionId: string,
+  ): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO turn_runtime_origins (
+        turn_id, local_session_id, agent_name, remote_session_id, created_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `).run(turnId, localSessionId, agentName, remoteSessionId, new Date().toISOString());
+  }
+
+  getTurnRuntimeOrigin(turnId: string): TurnRuntimeOriginRecord | undefined {
+    const row = this.db.prepare(`
+      SELECT turn_id, local_session_id, agent_name, remote_session_id, created_at
+      FROM turn_runtime_origins
+      WHERE turn_id = ?
+    `).get(turnId) as {
+      turn_id: string;
+      local_session_id: string;
+      agent_name: string;
+      remote_session_id: string;
+      created_at: string;
+    } | undefined;
+    return row
+      ? {
+          turnId: row.turn_id,
+          localSessionId: row.local_session_id,
+          agentName: row.agent_name,
+          remoteSessionId: row.remote_session_id,
+          createdAt: row.created_at,
+        }
+      : undefined;
+  }
+
+  saveTurnParent(turnId: string, localSessionId: string, parentTurnId?: string): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO turn_parent_links (
+        turn_id, local_session_id, parent_turn_id, created_at
+      ) VALUES (?, ?, ?, ?)
+    `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString());
+  }
+
   findLatestCompletedTurnId(localSessionId: string, contextKey: string): string | undefined {
     const row = this.db
       .prepare(`
@@ -626,6 +685,143 @@ export class StateStore {
     return row?.turn_id;
   }
 
+  countCompletedTurnSnapshots(localSessionId: string, contextKey: string): number {
+    const row = this.db.prepare(`
+      SELECT count(*) AS count
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND context_key = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+    `).get(localSessionId, contextKey) as { count: number };
+    return row.count;
+  }
+
+  listCompletedTurnSnapshots(
+    localSessionId: string,
+    contextKey: string,
+    limit: number,
+    offset = 0,
+  ): CompletedTurnSnapshotRecord[] {
+    const normalizedLimit = Math.max(1, Math.min(100, Math.trunc(limit)));
+    const normalizedOffset = Math.max(0, Math.trunc(offset));
+    const rows = this.db.prepare(`
+      SELECT turn_id, snapshot_json, updated_at
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND context_key = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+      ORDER BY
+        coalesce(
+          json_extract(snapshot_json, '$.completedAt'),
+          json_extract(snapshot_json, '$.startedAt'),
+          0
+        ) DESC,
+        updated_at DESC
+      LIMIT ? OFFSET ?
+    `).all(localSessionId, contextKey, normalizedLimit, normalizedOffset) as Array<{
+      turn_id: string;
+      snapshot_json: string;
+      updated_at: string;
+    }>;
+    return rows.map((row) => ({
+      turnId: row.turn_id,
+      snapshot: JSON.parse(row.snapshot_json),
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  listCompletedTurnGraph(
+    localSessionId: string,
+    contextKey: string,
+  ): CompletedTurnSnapshotRecord[] {
+    this.backfillTurnParents(localSessionId);
+    const rows = this.db.prepare(`
+      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
+      FROM turn_snapshots ts
+      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
+      WHERE ts.local_session_id = ?
+        AND ts.context_key = ?
+        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
+      ORDER BY
+        coalesce(
+          json_extract(ts.snapshot_json, '$.completedAt'),
+          json_extract(ts.snapshot_json, '$.startedAt'),
+          0
+        ) DESC,
+        ts.updated_at DESC
+    `).all(localSessionId, contextKey) as Array<{
+      turn_id: string;
+      parent_turn_id: string | null;
+      snapshot_json: string;
+      updated_at: string;
+    }>;
+    return rows.map((row) => ({
+      turnId: row.turn_id,
+      parentTurnId: row.parent_turn_id ?? undefined,
+      snapshot: JSON.parse(row.snapshot_json),
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  private backfillTurnParents(localSessionId: string): void {
+    const turns = this.db.prepare(`
+      SELECT
+        turn_id,
+        coalesce(
+          json_extract(snapshot_json, '$.startedAt'),
+          json_extract(snapshot_json, '$.completedAt'),
+          cast(strftime('%s', updated_at) AS INTEGER) * 1000,
+          0
+        ) AS started_at
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+      ORDER BY started_at ASC, updated_at ASC
+    `).all(localSessionId) as Array<{ turn_id: string; started_at: number }>;
+    if (turns.length === 0) return;
+
+    const existing = new Set((this.db.prepare(`
+      SELECT turn_id FROM turn_parent_links WHERE local_session_id = ?
+    `).all(localSessionId) as Array<{ turn_id: string }>).map((row) => row.turn_id));
+    const resets = (this.db.prepare(`
+      SELECT payload_json, created_at
+      FROM audit_events
+      WHERE event_type = 'session_reset_to_turn'
+        AND json_extract(payload_json, '$.localSessionId') = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(localSessionId) as Array<{ payload_json: string; created_at: string }>).flatMap((row) => {
+      try {
+        const payload = JSON.parse(row.payload_json) as { resetTurnId?: unknown };
+        const resetTurnId = typeof payload.resetTurnId === "string" ? payload.resetTurnId : undefined;
+        const at = Date.parse(row.created_at);
+        return resetTurnId && Number.isFinite(at) ? [{ resetTurnId, at }] : [];
+      } catch {
+        return [];
+      }
+    });
+
+    let headTurnId: string | undefined;
+    let resetIndex = 0;
+    const insert = this.db.prepare(`
+      INSERT OR IGNORE INTO turn_parent_links (
+        turn_id, local_session_id, parent_turn_id, created_at
+      ) VALUES (?, ?, ?, ?)
+    `);
+    const backfill = this.db.transaction(() => {
+      for (const turn of turns) {
+        while (resetIndex < resets.length && resets[resetIndex]!.at <= turn.started_at) {
+          headTurnId = resets[resetIndex]!.resetTurnId;
+          resetIndex += 1;
+        }
+        if (!existing.has(turn.turn_id)) {
+          insert.run(turn.turn_id, localSessionId, headTurnId ?? null, new Date().toISOString());
+        }
+        headTurnId = turn.turn_id;
+      }
+    });
+    backfill();
+  }
+
   saveTurnDelivery(
     turnId: string,
     patch: { progressMessageId?: string; lastCardHash?: string },
@@ -784,6 +980,31 @@ export class StateStore {
     return rows.map(mapSession);
   }
 
+  findLatestMessageIdForSession(localSessionId: string, contextKey?: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT message_id
+      FROM message_reactions
+      WHERE local_session_id = ?
+        AND (? IS NULL OR context_key = ?)
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT 1
+    `).get(localSessionId, contextKey ?? null, contextKey ?? null) as { message_id: string } | undefined;
+    return row?.message_id;
+  }
+
+  findLatestMessageIdForContext(contextKey: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT json_extract(payload_json, '$.messageId') AS message_id
+      FROM audit_events
+      WHERE context_key = ?
+        AND event_type = 'incoming_message'
+        AND json_type(payload_json, '$.messageId') = 'text'
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(contextKey) as { message_id: string } | undefined;
+    return row?.message_id;
+  }
+
   getServerActivityState(): {
     runningSessions: number;
     pendingFinalDeliveries: number;

package/src/state/migrations.ts

@@ -125,4 +125,25 @@ export const migrations = [
   CREATE INDEX IF NOT EXISTS idx_queued_prompts_session_order
     ON queued_prompts(local_session_id, created_at);
   `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_runtime_origins (
+    turn_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    agent_name TEXT NOT NULL,
+    remote_session_id TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_turn_runtime_origins_session
+    ON turn_runtime_origins(local_session_id);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_parent_links (
+    turn_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    parent_turn_id TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_turn_parent_links_session
+    ON turn_parent_links(local_session_id);
+  `,
 ] as const;

package/src/supervision/SafeRestartNotifier.ts

@@ -1,8 +1,9 @@
 import type { Logger } from "pino";
 import { CardRenderer } from "../feishu/CardRenderer.js";
+import { isThreadContextKey } from "../feishu/contextKey.js";
 import type { FeishuOutbound } from "../feishu/types.js";
 import type { StateStore } from "../state/StateStore.js";
-import type { SafeRestartStatus } from "./SafeRestartScheduler.js";
+import type { RestartNotificationTarget, SafeRestartStatus } from "./SafeRestartScheduler.js";
 
 const DEFAULT_INITIAL_CARD_DELAY_MS = 3_000;
 
@@ -13,6 +14,7 @@ export interface SafeRestartNotifierOptions {
 export class SafeRestartNotifier {
   private readonly messageIds = new Map<string, string>();
   private readonly cardHashes = new Map<string, string>();
+  private readonly notificationTargets = new Map<string, RestartNotificationTarget>();
   private activeScheduleId?: number;
   private terminalScheduleId?: number;
   private pendingInitialStatus?: SafeRestartStatus;
@@ -41,8 +43,10 @@ export class SafeRestartNotifier {
       this.activeScheduleId = status.scheduleId;
       this.messageIds.clear();
       this.cardHashes.clear();
+      this.notificationTargets.clear();
       this.clearInitialCardTimer();
       this.pendingInitialStatus = status;
+      this.collectNotificationTargets(status);
       const delayMs = status.phase === "cancelled"
         ? 0
         : this.options.initialCardDelayMs ?? DEFAULT_INITIAL_CARD_DELAY_MS;
@@ -55,6 +59,7 @@ export class SafeRestartNotifier {
       }, delayMs);
       return Promise.resolve();
     }
+    this.collectNotificationTargets(status);
     if (this.pendingInitialStatus) {
       this.pendingInitialStatus = status;
       return Promise.resolve();
@@ -67,6 +72,10 @@ export class SafeRestartNotifier {
     await this.queue;
   }
 
+  getNotificationTargets(): RestartNotificationTarget[] {
+    return [...this.notificationTargets.values()].map((target) => ({ ...target }));
+  }
+
   private publishPendingInitialStatus(): Promise<void> {
     this.clearInitialCardTimer();
     const status = this.pendingInitialStatus;
@@ -89,7 +98,8 @@ export class SafeRestartNotifier {
   }
 
   private async publish(status: SafeRestartStatus): Promise<void> {
-    const targets = this.store.listChatContexts("p2p");
+    this.collectNotificationTargets(status);
+    const targets = this.getNotificationTargets();
     if (targets.length === 0) return;
     const waitingTasks = status.phase === "cancelled"
       ? []
@@ -109,7 +119,7 @@ export class SafeRestartNotifier {
     });
     const cardHash = JSON.stringify(card);
 
-    await Promise.all(targets.map(async ({ contextKey }) => {
+    await Promise.all(targets.map(async ({ contextKey, replyMessageId }) => {
       const messageId = this.messageIds.get(contextKey);
       if (messageId) {
         if (this.cardHashes.get(contextKey) === cardHash) return;
@@ -124,7 +134,22 @@ export class SafeRestartNotifier {
         }
       }
       try {
-        const created = await this.outbound.sendInteractiveCard(contextKey, card);
+        let created: string | undefined;
+        if (isThreadContextKey(contextKey) && !replyMessageId) {
+          throw new Error("The safe-restart topic target has no reply message anchor.");
+        }
+        if (replyMessageId) {
+          if (!this.outbound.replyInteractiveCard) {
+            throw new Error("The outbound transport cannot preserve the requesting thread.");
+          }
+          created = await this.outbound.replyInteractiveCard(
+            contextKey,
+            { messageId: replyMessageId, replyInThread: true },
+            card,
+          );
+        } else {
+          created = await this.outbound.sendInteractiveCard(contextKey, card);
+        }
         if (created && this.activeScheduleId === status.scheduleId) {
           this.messageIds.set(contextKey, created);
           this.cardHashes.set(contextKey, cardHash);
@@ -134,4 +159,28 @@ export class SafeRestartNotifier {
       }
     }));
   }
+
+  private collectNotificationTargets(status: SafeRestartStatus): void {
+    const requestedTargets: RestartNotificationTarget[] = status.notificationTargets
+      ?? this.store.listChatContexts("p2p").map(({ contextKey }) => ({ contextKey }));
+    const recentTargets: RestartNotificationTarget[] = this.store.listRecentlyActiveChatContexts(
+      new Date(Date.now() - 60_000),
+    )
+      .filter((chat) => !isThreadContextKey(chat.contextKey))
+      .map(({ contextKey }) => ({ contextKey }));
+    for (const target of [
+      ...requestedTargets,
+      ...recentTargets,
+    ]) {
+      const contextKey = target.contextKey.trim();
+      if (!contextKey) continue;
+      const existing = this.notificationTargets.get(contextKey);
+      if (!existing || (!existing.replyMessageId && target.replyMessageId)) {
+        this.notificationTargets.set(contextKey, {
+          contextKey,
+          ...(target.replyMessageId?.trim() ? { replyMessageId: target.replyMessageId.trim() } : {}),
+        });
+      }
+    }
+  }
 }

package/src/supervision/SafeRestartScheduler.ts

@@ -11,9 +11,15 @@ export type SafeRestartPhase =
   | "restarting"
   | "cancelled";
 
+export interface RestartNotificationTarget {
+  contextKey: string;
+  replyMessageId?: string;
+}
+
 export interface SafeRestartStatus {
   scheduleId: number;
   reason: string;
+  notificationTargets?: RestartNotificationTarget[];
   phase: SafeRestartPhase;
   activity: ServerActivityState;
   remainingMs?: number;
@@ -21,7 +27,7 @@ export interface SafeRestartStatus {
 
 export interface SafeRestartSchedulerOptions {
   readActivity(): ServerActivityState;
-  onReady(reason: string): void | Promise<void>;
+  onReady(reason: string, notificationTargets: RestartNotificationTarget[]): void | Promise<void>;
   onStatus?(status: SafeRestartStatus): void | Promise<void>;
   onStatusError?(error: unknown): void;
   quietPeriodMs?: number;
@@ -33,6 +39,7 @@ export class SafeRestartScheduler {
   private polling?: Promise<void>;
   private pollAgain = false;
   private reason?: string;
+  private notificationTargets: RestartNotificationTarget[] = [];
   private idleSince?: number;
   private idleInboundAt?: string;
   private scheduleId = 0;
@@ -47,9 +54,13 @@ export class SafeRestartScheduler {
     return this.reason;
   }
 
-  schedule(reason: string): boolean {
+  schedule(reason: string, notificationTarget?: RestartNotificationTarget): boolean {
     const newlyScheduled = !this.reason;
-    if (newlyScheduled) this.scheduleId += 1;
+    if (newlyScheduled) {
+      this.scheduleId += 1;
+      this.notificationTargets = [];
+    }
+    this.addNotificationTarget(notificationTarget);
     this.reason = reason;
     this.idleSince = undefined;
     this.idleInboundAt = undefined;
@@ -73,10 +84,12 @@ export class SafeRestartScheduler {
     const reason = this.reason;
     if (!reason || this.scheduleId !== expectedScheduleId) return false;
     const activity = this.options.readActivity();
+    const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
     await this.emitStatus({
       scheduleId: expectedScheduleId,
       reason,
+      notificationTargets,
       phase: "cancelled",
       activity,
     });
@@ -87,6 +100,7 @@ export class SafeRestartScheduler {
     if (this.timer) clearInterval(this.timer);
     this.timer = undefined;
     this.reason = undefined;
+    this.notificationTargets = [];
     this.idleSince = undefined;
     this.idleInboundAt = undefined;
   }
@@ -101,6 +115,7 @@ export class SafeRestartScheduler {
       await this.emitStatus({
         scheduleId: this.scheduleId,
         reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
         phase: state.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
         activity: state,
       });
@@ -111,12 +126,26 @@ export class SafeRestartScheduler {
     if (this.idleSince === undefined || this.idleInboundAt !== latestInboundAt) {
       this.idleSince = Date.now();
       this.idleInboundAt = latestInboundAt;
-      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs: quietPeriodMs });
+      await this.emitStatus({
+        scheduleId: this.scheduleId,
+        reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
+        phase: "countdown",
+        activity: state,
+        remainingMs: quietPeriodMs,
+      });
       return;
     }
     const remainingMs = Math.max(0, quietPeriodMs - (Date.now() - this.idleSince));
     if (remainingMs > 0) {
-      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs });
+      await this.emitStatus({
+        scheduleId: this.scheduleId,
+        reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
+        phase: "countdown",
+        activity: state,
+        remainingMs,
+      });
       return;
     }
     const confirmed = this.options.readActivity();
@@ -131,6 +160,7 @@ export class SafeRestartScheduler {
         await this.emitStatus({
           scheduleId: this.scheduleId,
           reason,
+          notificationTargets: this.notificationTargetsSnapshot(),
           phase: confirmed.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
           activity: confirmed,
         });
@@ -138,6 +168,7 @@ export class SafeRestartScheduler {
         await this.emitStatus({
           scheduleId: this.scheduleId,
           reason,
+          notificationTargets: this.notificationTargetsSnapshot(),
           phase: "countdown",
           activity: confirmed,
           remainingMs: quietPeriodMs,
@@ -146,9 +177,17 @@ export class SafeRestartScheduler {
       return;
     }
     const scheduleId = this.scheduleId;
+    const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
-    await this.emitStatus({ scheduleId, reason, phase: "restarting", activity: confirmed, remainingMs: 0 });
-    await this.options.onReady(reason);
+    await this.emitStatus({
+      scheduleId,
+      reason,
+      notificationTargets,
+      phase: "restarting",
+      activity: confirmed,
+      remainingMs: 0,
+    });
+    await this.options.onReady(reason, notificationTargets);
   }
 
   private requestPoll(): void {
@@ -175,4 +214,36 @@ export class SafeRestartScheduler {
       this.options.onStatusError?.(error);
     });
   }
+
+  private addNotificationTarget(value: RestartNotificationTarget | undefined): void {
+    const target = normalizedNotificationTarget(value);
+    if (!target) return;
+    const existingIndex = this.notificationTargets.findIndex(
+      (candidate) => candidate.contextKey === target.contextKey,
+    );
+    if (existingIndex < 0) {
+      this.notificationTargets.push(target);
+      return;
+    }
+    const existing = this.notificationTargets[existingIndex]!;
+    if (!existing.replyMessageId && target.replyMessageId) {
+      this.notificationTargets[existingIndex] = target;
+    }
+  }
+
+  private notificationTargetsSnapshot(): RestartNotificationTarget[] {
+    return this.notificationTargets.map((target) => ({ ...target }));
+  }
+}
+
+function normalizedNotificationTarget(
+  value: RestartNotificationTarget | undefined,
+): RestartNotificationTarget | undefined {
+  const contextKey = value?.contextKey.trim();
+  if (!contextKey) return undefined;
+  const replyMessageId = value?.replyMessageId?.trim();
+  return {
+    contextKey,
+    ...(replyMessageId ? { replyMessageId } : {}),
+  };
 }

package/src/supervision/replacementSupervisor.ts

@@ -1,10 +1,36 @@
+export const RESTART_GROUP_CONTEXTS_ENV = "AGENT_BOT_RESTART_GROUP_CONTEXTS";
+
 export function replacementSupervisorEnvironment(
   restartReason: string,
   environment: NodeJS.ProcessEnv = process.env,
+  restartGroupContextKeys: readonly string[] = [],
 ): NodeJS.ProcessEnv {
-  return {
+  const result: NodeJS.ProcessEnv = {
     ...environment,
     AGENT_BOT_START_DELAY_MS: "250",
     AGENT_BOT_RESTART_REASON: restartReason,
   };
+  const normalized = normalizedContextKeys(restartGroupContextKeys);
+  if (normalized.length > 0) {
+    result[RESTART_GROUP_CONTEXTS_ENV] = JSON.stringify(normalized);
+  } else {
+    delete result[RESTART_GROUP_CONTEXTS_ENV];
+  }
+  return result;
+}
+
+export function restartGroupContextKeysFromEnvironment(value: string | undefined): string[] {
+  if (!value?.trim()) return [];
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed)
+      ? normalizedContextKeys(parsed.filter((entry): entry is string => typeof entry === "string"))
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+function normalizedContextKeys(values: readonly string[]): string[] {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }