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

package/src/proxy/ProxySessionController.ts

@@ -2503,17 +2503,28 @@ export class ProxySessionController {
 
   private async presentPromptQueueCard(localSessionId: string, contextKey: string): Promise<void> {
     await this.serializePromptQueueCardWrite(localSessionId, async () => {
-      const card = this.renderPromptQueueCard(localSessionId, contextKey);
-      const existing = this.queuedPromptCards.get(localSessionId)?.get(contextKey);
+      const cards = this.queuedPromptCards.get(localSessionId);
+      const existing = cards?.get(contextKey);
       if (existing) {
         try {
-          await this.outbound.updateInteractiveCard(contextKey, existing, card);
-          return;
+          await this.outbound.updateInteractiveCard(
+            contextKey,
+            existing,
+            this.renderPromptQueueCard(localSessionId, contextKey, "superseded"),
+          );
         } catch (error) {
-          this.logger.warn({ error, localSessionId, contextKey, messageId: existing }, "Failed to update prompt queue card; sending a replacement.");
+          this.logger.warn(
+            { error, localSessionId, contextKey, messageId: existing },
+            "Failed to stop the previous prompt queue card; sending a replacement.",
+          );
         }
+        cards?.delete(contextKey);
+        if (cards?.size === 0) this.queuedPromptCards.delete(localSessionId);
       }
-      const messageId = await this.outbound.sendInteractiveCard(contextKey, card);
+      const messageId = await this.outbound.sendInteractiveCard(
+        contextKey,
+        this.renderPromptQueueCard(localSessionId, contextKey),
+      );
       if (messageId) this.rememberPromptQueueCard(localSessionId, contextKey, messageId);
     });
   }
@@ -2536,10 +2547,15 @@ export class ProxySessionController {
     });
   }
 
-  private renderPromptQueueCard(localSessionId: string, contextKey: string): Record<string, unknown> {
+  private renderPromptQueueCard(
+    localSessionId: string,
+    contextKey: string,
+    phase: "active" | "superseded" = "active",
+  ): Record<string, unknown> {
     return this.cardRenderer.renderPromptQueue({
       sessionId: localSessionId,
       contextKey,
+      phase,
       prompts: this.store.listQueuedPrompts(localSessionId).map((prompt) => ({
         id: prompt.promptId,
         text: prompt.displayPrompt ?? prompt.text,
@@ -4835,7 +4851,43 @@ export class ProxySessionController {
     if (!current.remoteSessionId || !this.isCodexSession(current)) {
       throw new Error("当前任务不是可 Reset 的 App Server 任务。");
     }
-    const allTurns = this.store.listTaskTurnGraph(current.localSessionId);
+    const completedTurns = this.store.listTaskTurnGraph(current.localSessionId);
+    const completedTurnIds = new Set(completedTurns.map((turn) => turn.turnId));
+    const runningTurnId = current.lastTurnStatus === "running" && current.lastTurnId
+      && !completedTurnIds.has(current.lastTurnId)
+      ? current.lastTurnId
+      : undefined;
+    const persistedRunningSnapshot = runningTurnId
+      ? turnViewSnapshot(this.store.getTurnSnapshot(runningTurnId))
+      : undefined;
+    const runningAttempt = runningTurnId
+      ? this.store.findIncompleteTurnAttemptByTurnId(runningTurnId)
+      : undefined;
+    const attemptStartedAt = Date.parse(runningAttempt?.createdAt ?? "");
+    const runningSnapshot: TurnViewState | undefined = runningTurnId
+      ? persistedRunningSnapshot ?? {
+          sessionId: current.localSessionId,
+          turnId: runningTurnId,
+          prompt: runningAttempt?.promptText ?? current.title,
+          status: "running",
+          startedAt: Number.isFinite(attemptStartedAt) ? attemptStartedAt : Date.now(),
+          assistantText: "",
+          plan: [],
+          activities: [],
+          completedTools: [],
+          failedTools: [],
+          fileSummary: [],
+        }
+      : undefined;
+    const runningTurn = runningTurnId && runningSnapshot
+      ? {
+          turnId: runningTurnId,
+          parentTurnId: this.store.getTurnParent(runningTurnId, current.localSessionId),
+          snapshot: runningSnapshot,
+          updatedAt: runningAttempt?.updatedAt ?? new Date(runningSnapshot.startedAt).toISOString(),
+        }
+      : undefined;
+    const allTurns = runningTurn ? [runningTurn, ...completedTurns] : completedTurns;
     const graphRows = buildTurnGraphRows(allTurns.map((turn) => ({
       turnId: turn.turnId,
       parentTurnId: turn.parentTurnId,
@@ -4854,16 +4906,18 @@ export class ProxySessionController {
         100,
       );
       const isCurrent = current.lastTurnId === turn.turnId && current.lastTurnStatus === "completed";
+      const isRunning = runningTurnId === turn.turnId;
       return [{
         sequence: graph.sequence,
         graphNodeLine: graph.nodeLine,
         graphConnectorLine: graph.connectorLine,
         lines: [
-          `**${cardText(summary || "未记录对话内容")}**`,
-          `${formatResetTurnTime(snapshot.completedAt ?? snapshot.startedAt)} · ${cardCode(turn.turnId)}`,
+          cardText(summary || "未记录对话内容"),
+          `${formatResetTurnTime(snapshot.completedAt ?? snapshot.startedAt)} · ${cardText(turn.turnId)}`,
         ],
         current: isCurrent,
-        actions: isCurrent ? undefined : [{
+        running: isRunning,
+        actions: isCurrent || isRunning ? undefined : [{
           text: "Reset",
           value: {
             action: "turn_reset",
@@ -4899,7 +4953,9 @@ export class ProxySessionController {
     const card = this.cardRenderer.renderResetHistoryCard({
       entries,
       footerLines: [
-        `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
+        runningTurn
+          ? `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个 turn（${completedTurns.length} 个已完成，1 个运行中）`
+          : `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
       ],
       pageActions,
     });
@@ -5266,8 +5322,8 @@ export class ProxySessionController {
           reference: entry.reference,
           summary: `${offset + index + 1}. ${marker}${title} · ${entry.agentName}`,
           detailLines: [
-            cardText(lastUserPrompt),
-            `**更新时间**：${cardText(entry.updatedLabel)}`,
+            `**最新 Prompt**：${cardText(lastUserPrompt)}`,
+            `<font color='grey'>最近更新：${cardText(entry.updatedLabel)}</font>`,
           ],
           actions,
           current: entry.current,

package/src/state/StateStore.ts

@@ -1057,6 +1057,15 @@ export class StateStore {
     `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString());
   }
 
+  getTurnParent(turnId: string, localSessionId: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT parent_turn_id
+      FROM turn_parent_links
+      WHERE turn_id = ? AND local_session_id = ?
+    `).get(turnId, localSessionId) as { parent_turn_id: string | null } | undefined;
+    return row?.parent_turn_id ?? undefined;
+  }
+
   findLatestCompletedTurnId(localSessionId: string, contextKey: string): string | undefined {
     const row = this.db
       .prepare(`

package/src/supervision/SafeRestartNotifier.ts

@@ -17,6 +17,7 @@ export class SafeRestartNotifier {
   private readonly notificationTargets = new Map<string, RestartNotificationTarget>();
   private activeScheduleId?: number;
   private terminalScheduleId?: number;
+  private lastStatus?: SafeRestartStatus;
   private pendingInitialStatus?: SafeRestartStatus;
   private initialCardTimer?: NodeJS.Timeout;
   private queue = Promise.resolve();
@@ -40,12 +41,24 @@ export class SafeRestartNotifier {
       this.terminalScheduleId = Math.max(this.terminalScheduleId ?? 0, status.scheduleId);
     }
     if (this.activeScheduleId !== status.scheduleId) {
+      const previousStatus = this.lastStatus ?? this.pendingInitialStatus;
+      const previousMessageIds = [...this.messageIds];
+      const previousTargets = new Map(this.notificationTargets);
+      if (
+        previousStatus
+        && previousStatus.phase !== "cancelled"
+        && previousStatus.phase !== "restarting"
+        && previousMessageIds.length > 0
+      ) {
+        this.enqueueSupersededCards(previousStatus, previousMessageIds, previousTargets);
+      }
       this.activeScheduleId = status.scheduleId;
       this.messageIds.clear();
       this.cardHashes.clear();
       this.notificationTargets.clear();
       this.clearInitialCardTimer();
       this.pendingInitialStatus = status;
+      this.lastStatus = status;
       this.collectNotificationTargets(status);
       const delayMs = status.phase === "cancelled"
         ? 0
@@ -59,6 +72,7 @@ export class SafeRestartNotifier {
       }, delayMs);
       return Promise.resolve();
     }
+    this.lastStatus = status;
     this.collectNotificationTargets(status);
     if (this.pendingInitialStatus) {
       this.pendingInitialStatus = status;
@@ -149,9 +163,13 @@ export class SafeRestartNotifier {
         } else {
           created = await this.outbound.sendInteractiveCard(contextKey, card);
         }
-        if (created && this.activeScheduleId === status.scheduleId) {
-          this.messageIds.set(contextKey, created);
-          this.cardHashes.set(contextKey, cardHash);
+        if (created) {
+          if (this.activeScheduleId === status.scheduleId) {
+            this.messageIds.set(contextKey, created);
+            this.cardHashes.set(contextKey, cardHash);
+          } else {
+            await this.stopCard(created, status, reason ?? status.reason);
+          }
         }
       } catch (error) {
         this.logger.warn({ error, contextKey }, "Failed to send safe restart status card.");
@@ -159,6 +177,37 @@ export class SafeRestartNotifier {
     }));
   }
 
+  private enqueueSupersededCards(
+    status: SafeRestartStatus,
+    messageIds: Array<[string, string]>,
+    targets: Map<string, RestartNotificationTarget>,
+  ): void {
+    const queued = this.queue.catch(() => undefined).then(async () => {
+      await Promise.all(messageIds.map(async ([contextKey, messageId]) => {
+        const reason = targets.get(contextKey)?.reason ?? status.reason;
+        await this.stopCard(messageId, status, reason);
+      }));
+    });
+    this.queue = queued;
+  }
+
+  private async stopCard(messageId: string, status: SafeRestartStatus, reason: string): Promise<void> {
+    try {
+      await this.outbound.updateInteractiveCard(messageId, this.renderer.renderSafeRestartStatus({
+        scheduleId: status.scheduleId,
+        reason,
+        phase: "superseded",
+        pendingFinalDeliveries: status.activity.pendingFinalDeliveries,
+        waitingTasks: [],
+      }));
+    } catch (error) {
+      this.logger.warn(
+        { error, messageId, scheduleId: status.scheduleId },
+        "Failed to stop a superseded safe restart status card.",
+      );
+    }
+  }
+
   private collectNotificationTargets(status: SafeRestartStatus): void {
     for (const target of status.notificationTargets ?? []) {
       const contextKey = target.contextKey.trim();

package/src/supervision/SafeRestartScheduler.ts

@@ -58,9 +58,9 @@ export class SafeRestartScheduler {
   schedule(reason: string, notificationTarget?: RestartNotificationTarget): boolean {
     const newlyScheduled = !this.reason;
     if (newlyScheduled) {
-      this.scheduleId += 1;
       this.notificationTargets = [];
     }
+    this.scheduleId += 1;
     this.addNotificationTarget(notificationTarget, reason);
     this.reason = reason;
     this.idleSince = undefined;
@@ -109,12 +109,13 @@ export class SafeRestartScheduler {
   private async poll(): Promise<void> {
     const reason = this.reason;
     if (!reason) return;
+    const scheduleId = this.scheduleId;
     const state = this.options.readActivity();
     if (state.runningSessions > 0 || state.pendingFinalDeliveries > 0) {
       this.idleSince = undefined;
       this.idleInboundAt = undefined;
       await this.emitStatus({
-        scheduleId: this.scheduleId,
+        scheduleId,
         reason,
         notificationTargets: this.notificationTargetsSnapshot(),
         phase: state.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
@@ -128,7 +129,7 @@ export class SafeRestartScheduler {
       this.idleSince = Date.now();
       this.idleInboundAt = latestInboundAt;
       await this.emitStatus({
-        scheduleId: this.scheduleId,
+        scheduleId,
         reason,
         notificationTargets: this.notificationTargetsSnapshot(),
         phase: "countdown",
@@ -140,7 +141,7 @@ export class SafeRestartScheduler {
     const remainingMs = Math.max(0, quietPeriodMs - (Date.now() - this.idleSince));
     if (remainingMs > 0) {
       await this.emitStatus({
-        scheduleId: this.scheduleId,
+        scheduleId,
         reason,
         notificationTargets: this.notificationTargetsSnapshot(),
         phase: "countdown",
@@ -159,7 +160,7 @@ export class SafeRestartScheduler {
       this.idleInboundAt = undefined;
       if (confirmed.runningSessions > 0 || confirmed.pendingFinalDeliveries > 0) {
         await this.emitStatus({
-          scheduleId: this.scheduleId,
+          scheduleId,
           reason,
           notificationTargets: this.notificationTargetsSnapshot(),
           phase: confirmed.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
@@ -167,7 +168,7 @@ export class SafeRestartScheduler {
         });
       } else {
         await this.emitStatus({
-          scheduleId: this.scheduleId,
+          scheduleId,
           reason,
           notificationTargets: this.notificationTargetsSnapshot(),
           phase: "countdown",
@@ -177,7 +178,6 @@ export class SafeRestartScheduler {
       }
       return;
     }
-    const scheduleId = this.scheduleId;
     const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
     await this.emitStatus({
@@ -230,7 +230,7 @@ export class SafeRestartScheduler {
     this.notificationTargets[existingIndex] = {
       ...existing,
       reason: target.reason,
-      ...(!existing.replyMessageId && target.replyMessageId
+      ...(target.replyMessageId
         ? { replyMessageId: target.replyMessageId }
         : {}),
     };