@keyou007/agent-bot 0.1.24-alpha.6 → 0.1.24-alpha.7

package/skills/agent-bot/SKILL.md

@@ -115,7 +115,7 @@ Feishu group renames update only the group's currently bound task title, not top
 
 Fork creation stores source-task and branch-Turn references without synchronizing the full local Turn list. The Feishu Turn card reuses local records and loads only the summary pages needed for the requested page, not the entire history. `task turns` loads the first page if necessary and returns available local records. This does not change the Agent's inherited context. Retry listing Turns after a temporary history-read failure; unsupported summary pagination never falls back to downloading full history.
 
-TraeX plan-mode confirmations follow the task permission mode. With `auto`, Agent Bot automatically accepts Enter Plan Mode and Approve Plan; do not also approve or send a continuation prompt. With `confirm`, `Approve Plan` / `Enter Plan Mode`, `Reject`, and `Cancel Request` require the user's choice. Approval requests and decisions stay in the same thinking card and live Preview, explicitly labeling automatic approvals. If an automatic response fails, the card offers manual confirmation with an error notice; never pretend it succeeded. Approved implementation continues in the same task and card. Explicit discussion-only or no-implementation instructions still apply. Preview cannot approve, cancelling a request does not itself stop the task, and waiting turns still block safe restart. Do not stop or force-restart merely to clear that wait. Missed notifications from older versions are not automatically replayed.
+TraeX plan-mode confirmations follow the task permission mode. With `auto`, Agent Bot automatically accepts Enter Plan Mode and Approve Plan; do not also approve or send a continuation prompt. With `confirm`, `Approve Plan` / `Enter Plan Mode`, `Reject`, and `Cancel Request` require the user's choice. Approval requests and decisions stay in the same thinking card and live Preview, explicitly labeling automatic approvals. If TraeX reports no pending request after automatically entering Plan mode, Agent Bot verifies the matching completed EnterPlanMode call before recording success. Missing requests alone are not proof of approval. Unverified automatic failures still offer manual confirmation with an error notice; never pretend they succeeded. Approved implementation continues in the same task and card. Explicit discussion-only or no-implementation instructions still apply. Preview cannot approve, cancelling a request does not itself stop the task, and waiting turns still block safe restart. Do not stop or force-restart merely to clear that wait. Missed notifications from older versions are not automatically replayed.
 
 ## Change Settings
 
@@ -207,6 +207,8 @@ The safe-restart card has matching `Cancel` and `ForceRestart` actions. Clicking
 
 Each displayed running task on that card has a `Stop` action targeting its exact task, even across conversations. It uses normal Agent interruption and leaves the restart scheduled; the card updates as tasks stop. Only stop a task when the user requests it.
 
+Blocking terminals are listed on the safe-restart card by their eight-character token, directory, activity/connection state, and current command when available. Activity means a connected foreground page, a known running command, or input/output within 30 seconds; inactive Shells still block restart. PowerShell/PSReadLine reports commands; other Shells may report only a foreground process or unknown. The owner-only End Terminal action stops exactly that Shell and waits for its exit without forcing restart. Never end a user's terminal merely to complete your own restart; require their explicit request. Stale/cancelled cards cannot close terminals.
+
 A bare `agentbot server restart` invoked inside an Agent Bot-started Agent returns restart status to the source task conversation. The same command from an ordinary terminal uses the configured user's private chat. Add `--task <task>` only to override either default.
 
 Never use `taskkill`, `Stop-Process`, or equivalent commands for routine restart management.

package/src/codex/CodexEventMapper.ts

@@ -4,6 +4,7 @@ import type { PlanStep, ToolState } from "../runtime/types.js";
 const modeChangeRequest = z.object({
   requestId: z.string().min(1),
   targetMode: z.enum(["plan", "default"]),
+  sourceToolCallId: z.string().min(1).nullish(),
   reason: z.string(),
   allowedPrompts: z.array(z.object({ tool: z.string(), prompt: z.string() })).optional(),
 });

package/src/codex/CodexRuntime.ts

@@ -1,4 +1,5 @@
 import { statSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
 import type { Logger } from "pino";
 import type {
   AgentRuntime,
@@ -34,6 +35,7 @@ import { AppServerRequestError } from "./AppServerConnection.js";
 import { workspaceSandboxFromConfig, workspaceSandboxFromResponse, type TurnSandboxPolicy, type WorkspaceSandboxPolicy } from "./AppServerPermissions.js";
 import { formatCodexError, mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
+import { hasCompletedTraePlanEntry } from "./TraePlanEntry.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
 import { threadWriterLockPath } from "./ThreadWriterProcess.js";
 import { assertProviderSettingsApplied, PROVIDER_SWITCH_BUSY, PROVIDER_SWITCH_EMPTY, ProviderSwitchError, providerSwitchFailure } from "./ProviderSwitch.js";
@@ -110,6 +112,7 @@ interface PendingModeChange {
   turnId: string;
   requestId: string;
   targetMode: "plan" | "default";
+  sourceToolCallId?: string;
   responding: boolean;
   decision?: ApprovalDecision;
   automatic?: boolean;
@@ -950,11 +953,15 @@ export class CodexRuntime implements AgentRuntime {
       try {
         const client = await this.client();
         if (this.modeChanges.get(requestId) !== modeChange) throw new Error("Approval request is no longer pending.");
-        await client.request("mode/change/respond", {
-          threadId: this.requireSession(sessionId).remoteSessionId,
-          requestId: modeChange.requestId,
-          decision: decision === "accept" ? "approved" : decision === "decline" ? "rejected" : "cancelled",
-        }, CONTROL_REQUEST_TIMEOUT_MS);
+        try {
+          await client.request("mode/change/respond", {
+            threadId: this.requireSession(sessionId).remoteSessionId,
+            requestId: modeChange.requestId,
+            decision: decision === "accept" ? "approved" : decision === "decline" ? "rejected" : "cancelled",
+          }, CONTROL_REQUEST_TIMEOUT_MS);
+        } catch (error) {
+          if (!await this.reconcileCompletedPlanEntry(requestId, modeChange, error)) throw error;
+        }
         if (this.modeChanges.get(requestId) === modeChange) {
           this.confirmPlanContinuation(modeChange, decision);
           this.modeChanges.delete(requestId);
@@ -974,6 +981,36 @@ export class CodexRuntime implements AgentRuntime {
     this.emit({ type: "approval_resolved", sessionId, turnId: pending.turnId, requestId, decision });
   }
 
+  private async reconcileCompletedPlanEntry(
+    requestId: string, pending: PendingModeChange, error: unknown,
+  ): Promise<boolean> {
+    const session = this.sessions.get(pending.sessionId);
+    if (!pending.automatic || pending.decision !== "accept" || pending.targetMode !== "plan"
+      || this.provider.getAgentFamily?.() !== "traex" || !session?.rolloutPath
+      || !(error instanceof AppServerRequestError) || error.method !== "mode/change/respond" || error.code !== -32600
+      || error.serverMessage !== `failed to respond to mode change request: No pending mode change found for request_id: ${pending.requestId}`) {
+      return false;
+    }
+    const toolCallId = pending.sourceToolCallId ?? pending.requestId;
+    for (const waitMs of [0, 100, 200]) {
+      if (waitMs) await delay(waitMs);
+      if (this.modeChanges.get(requestId) !== pending || this.sessions.get(pending.sessionId) !== session
+        || session.activeTurnId !== pending.turnId) return false;
+      try {
+        if (!await hasCompletedTraePlanEntry(session.rolloutPath, pending.turnId, toolCallId)) continue;
+        if (this.modeChanges.get(requestId) !== pending || this.sessions.get(pending.sessionId) !== session
+          || session.activeTurnId !== pending.turnId) return false;
+        this.logger.info({ sessionId: pending.sessionId, turnId: pending.turnId, requestId, toolCallId },
+          "Verified that TraeX already completed the automatic plan-mode entry.");
+        return true;
+      } catch (verificationError) {
+        this.logger.debug({ error: verificationError, sessionId: pending.sessionId, requestId },
+          "Could not verify TraeX plan-mode entry from the rollout tail.");
+      }
+    }
+    return false;
+  }
+
   async listModels(modelProvider?: string, fallbackModel?: string): Promise<ModelOption[]> {
     return (await this.listModelsWithStatus(modelProvider, fallbackModel)).models;
   }
@@ -1217,6 +1254,7 @@ export class CodexRuntime implements AgentRuntime {
       const pending: PendingModeChange = {
         sessionId, turnId: mapped.turnId, requestId: mapped.requestId,
         targetMode: mapped.targetMode, responding: false,
+        sourceToolCallId: mapped.sourceToolCallId ?? undefined,
       };
       this.modeChanges.set(requestId, pending);
       const automatic = session.permissionMode === "auto" && this.provider.getAgentFamily?.() === "traex";
@@ -1236,8 +1274,9 @@ export class CodexRuntime implements AgentRuntime {
       this.emit({ type: "approval_requested", sessionId, turnId: mapped.turnId, request });
       if (automatic) {
         void this.resolveApproval(sessionId, requestId, "accept", true).catch((error: unknown) => {
-          this.logger.warn({ error, sessionId, requestId }, "Failed to automatically approve the TraeX mode change.");
           if (this.modeChanges.get(requestId) !== pending || session.activeTurnId !== mapped.turnId) return;
+          this.logger.warn({ error, sessionId, requestId, turnId: mapped.turnId, targetMode: mapped.targetMode,
+            sourceToolCallId: pending.sourceToolCallId }, "Failed to automatically approve the TraeX mode change.");
           this.emit({ type: "approval_requested", sessionId, turnId: mapped.turnId,
             request: { ...request, automatic: false, reason: ["自动同意失败，请手动确认。", request.reason].filter(Boolean).join("\n\n") } });
         });

package/src/codex/TraePlanEntry.ts

@@ -0,0 +1,63 @@
+import { open } from "node:fs/promises";
+import { z } from "zod";
+
+const MAX_TAIL_BYTES = 256 * 1024;
+const mutation = z.object({
+  type: z.literal("history_mutation"),
+  payload: z.object({
+    version: z.literal(1),
+    turn_id: z.string(),
+    operation: z.string(),
+    items: z.array(z.object({
+      type: z.string(),
+      call_id: z.string().optional(),
+      name: z.string().optional(),
+      output: z.unknown().optional(),
+    })).optional(),
+  }),
+});
+
+// TraeX can finish EnterPlanMode without a mode/changeResolved notification.
+// Read only a bounded tail, and require the exact call and its successful result.
+export async function hasCompletedTraePlanEntry(
+  rolloutPath: string, turnId: string, toolCallId: string,
+): Promise<boolean> {
+  const file = await open(rolloutPath, "r");
+  try {
+    const { size } = await file.stat();
+    const start = Math.max(0, size - MAX_TAIL_BYTES);
+    const buffer = Buffer.alloc(size - start);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, start);
+    const text = buffer.subarray(0, bytesRead).toString("utf8");
+    const lines = text.split("\n");
+    if (start > 0) lines.shift();
+    lines.pop(); // Ignore an uncommitted/partial final record.
+    let entered = false;
+    let matchedCall = false;
+    for (const line of lines) {
+      let value: unknown;
+      try { value = JSON.parse(line); } catch { continue; }
+      const parsed = mutation.safeParse(value);
+      if (!parsed.success || parsed.data.payload.turn_id !== turnId) continue;
+      const payload = parsed.data.payload;
+      if (payload.operation !== "append") {
+        matchedCall = false;
+        entered = false;
+        continue;
+      }
+      for (const item of payload.items ?? []) {
+        if (item.call_id !== toolCallId) continue;
+        if (item.type === "function_call") {
+          matchedCall = item.name === "EnterPlanMode";
+          entered = false;
+        } else if (item.type === "function_call_output") {
+          entered = matchedCall && typeof item.output === "string"
+            && item.output.startsWith("Entered plan mode.");
+        }
+      }
+    }
+    return entered;
+  } finally {
+    await file.close();
+  }
+}

package/src/feishu/CardRenderer.ts

@@ -15,7 +15,7 @@ import type {
 import type { TurnActivity, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import type { UpdateNotice } from "../updates/types.js";
-import type { TerminalCardView } from "../terminal/TerminalServer.js";
+import type { ActiveTerminal, TerminalCardView } from "../terminal/TerminalServer.js";
 import { localCardImage } from "./LocalCardImage.js";
 
 export interface StartupStatusView {
@@ -61,6 +61,8 @@ export interface InitializationWelcomeView {
 
 export interface SafeRestartStatusView {
   activeTerminals?: number;
+  terminalBlockers?: ActiveTerminal[];
+  contextKey?: string;
   scheduleId: number;
   reason: string;
   phase: "waiting_tasks" | "waiting_delivery" | "countdown" | "restarting" | "cancelled" | "superseded";
@@ -1069,9 +1071,35 @@ export class CardRenderer {
       `**重启原因**：${inlineCode(view.reason)}`,
       `**重启倒计时**：${countdown}`,
       `**待投递结果**：${view.pendingFinalDeliveries} 条`,
-      ...(view.activeTerminals ? [`**活动终端**：${view.activeTerminals} 个，请在网页或原会话的终端管理卡中关闭。ForceRestart 会中断终端。`] : []),
+      ...(view.activeTerminals ? [`**活动终端**：${view.activeTerminals} 个。结束终端会中断其中的命令；ForceRestart 会中断所有终端。`] : []),
     ];
     const elements: Record<string, unknown>[] = [markdown(lines.join("\n"))];
+    if (view.terminalBlockers?.length) {
+      elements.push({ tag: "hr" }, markdown(`**阻止重启的终端（${view.terminalBlockers.length}）**`));
+      for (const terminal of view.terminalBlockers) {
+        const command = terminal.state === "closing" ? "正在结束，等待 Shell 退出"
+          : terminal.state === "starting" ? "Shell 启动中"
+          : terminal.command.status === "idle" ? "无（Shell 空闲）"
+          : terminal.command.command ? inlineCode(escapeCardHtml(truncateText(terminal.command.command.replace(/\s+/gu, " "), 240)))
+          : terminal.command.status === "running" ? "命令执行中（命令内容不可用）"
+          : "未知（Shell 未提供命令信息）";
+        const connection = terminal.connected ? terminal.foreground ? "网页前台" : "网页已连接" : "网页已断开";
+        const label = `**终端**：${inlineCode(terminal.token)} · ${terminal.active ? "活跃" : "不活跃"} · ${connection}\n**目录**：${inlineCode(escapeCardHtml(truncateText(terminal.cwd, 240)))}\n**${terminal.command.source === "process" ? "前台进程" : "正在执行"}**：${command}`;
+        elements.push({
+          tag: "column_set", flex_mode: "none", horizontal_spacing: "8px",
+          columns: [
+            { tag: "column", width: "weighted", weight: 1, elements: [markdown(label)] },
+            ...(actionable && terminal.state !== "closing" ? [{
+              tag: "column", width: "auto", elements: [taskActionElement({
+                text: "结束终端", type: "danger",
+                value: { action: "safe_restart_terminal_stop", scheduleId: String(view.scheduleId), terminalId: terminal.terminalId, ...(view.contextKey ? { contextKey: view.contextKey } : {}) },
+              })],
+            }] : []),
+          ],
+        });
+      }
+      elements.push(markdown("活跃：前台连接、正在执行命令或最近 30 秒有输入输出。不活跃的 Shell 仍会阻止安全重启。"));
+    }
     if (view.waitingTasks.length > 0) {
       const visible = view.waitingTasks.slice(0, 10);
       elements.push({ tag: "hr" }, markdown(`**当前等待的任务（${view.waitingTasks.length}）**`));

package/src/index.ts

@@ -145,7 +145,14 @@ if (feishuOutbound) {
     workspaceKind: defaultAgent?.kind === "app-server" ? "projectless" : "project",
     defaultUserOpenId: config.feishu.userOpenId,
   }, metadataHydrator);
-  safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger);
+  safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger, {
+    ownerId: () => config.feishu.userOpenId,
+    isCurrentSchedule: (scheduleId) => !shuttingDown && !restartRequested && safeRestart.isCurrentSchedule(scheduleId),
+    stopTerminal: (terminalId, userId) => {
+      if (!terminalServer) throw new Error("网页终端未启用。");
+      return terminalServer.stopActiveTerminal(terminalId, userId);
+    },
+  });
 }
 
 const consoleEnabled = consoleOnly || config.console.enabled || transport === "console";
@@ -253,8 +260,8 @@ if (feishuOutbound && localFileViewer && config.terminal?.enabled !== false) {
 
 function serverActivity() {
   const activity = store.getServerActivityState();
-  const activeTerminals = terminalServer?.activeCount ?? 0;
-  return { ...activity, activeTerminals };
+  const terminalBlockers = terminalServer?.listActiveTerminals() ?? [];
+  return { ...activity, activeTerminals: terminalBlockers.length, terminalBlockers };
 }
 
 const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
@@ -264,6 +271,10 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
     if (!terminalServer) throw new Error("网页终端未启用。");
     return terminalServer.resolveApproval(action);
   },
+  stopSafeRestartTerminal: (action) => {
+    if (!safeRestartNotifier) throw new Error("安全重启通知未启用。");
+    return safeRestartNotifier.stopTerminal(action);
+  },
   showUpdates: (contextKey, userId) => manualUpdates.show(contextKey, userId),
   selectUpdate: (action, replyTarget) => manualUpdates.select(action, replyTarget),
   restart: requestRestart,

package/src/proxy/ProxySessionController.ts

@@ -515,6 +515,7 @@ export interface ControlTaskReleaseResult {
 export interface ProxyLifecycle {
   terminalUrl?(jobId: string): string | undefined;
   authorizeTerminal?(action: CardAction): Promise<string>;
+  stopSafeRestartTerminal?(action: CardAction): Promise<string>;
   supervised?: boolean;
   restart(contextKey: string, force: boolean, replyTarget?: MessageReplyTarget): Promise<void>;
   cancelSafeRestart?(scheduleId: number): Promise<boolean>;
@@ -1035,6 +1036,9 @@ export class ProxySessionController {
         if (kind === "terminal_authorize") {
           if (!this.lifecycle?.authorizeTerminal) throw new Error("网页终端未启用。");
           await this.outbound.sendText(contextKey, await this.lifecycle.authorizeTerminal(scopedAction));
+        } else if (kind === "safe_restart_terminal_stop") {
+          if (!this.lifecycle?.stopSafeRestartTerminal) throw new Error("网页终端未启用。");
+          await this.outbound.sendText(contextKey, await this.lifecycle.stopSafeRestartTerminal(scopedAction));
         } else if (kind === "agentbot_update_cancel") {
           if (!this.lifecycle?.cancelAutomaticUpdate) throw new Error("自动更新功能未启用。");
           await this.lifecycle.cancelAutomaticUpdate(scopedAction);

package/src/supervision/SafeRestartNotifier.ts

@@ -1,7 +1,7 @@
 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 { CardAction, FeishuOutbound } from "../feishu/types.js";
 import type { StateStore } from "../state/StateStore.js";
 import type { RestartNotificationTarget, SafeRestartStatus } from "./SafeRestartScheduler.js";
 
@@ -9,11 +9,15 @@ const DEFAULT_INITIAL_CARD_DELAY_MS = 3_000;
 
 export interface SafeRestartNotifierOptions {
   initialCardDelayMs?: number;
+  ownerId?(): string | undefined;
+  isCurrentSchedule?(scheduleId: number): boolean;
+  stopTerminal?(terminalId: string, userId: string): Promise<boolean>;
 }
 
 export class SafeRestartNotifier {
   private readonly messageIds = new Map<string, string>();
   private readonly cardHashes = new Map<string, string>();
+  private readonly cardTerminalIds = new Map<string, Set<string>>();
   private readonly notificationTargets = new Map<string, RestartNotificationTarget>();
   private activeScheduleId?: number;
   private terminalScheduleId?: number;
@@ -55,6 +59,7 @@ export class SafeRestartNotifier {
       this.activeScheduleId = status.scheduleId;
       this.messageIds.clear();
       this.cardHashes.clear();
+      this.cardTerminalIds.clear();
       this.notificationTargets.clear();
       this.clearInitialCardTimer();
       this.pendingInitialStatus = status;
@@ -90,6 +95,25 @@ export class SafeRestartNotifier {
     return [...this.notificationTargets.values()].map((target) => ({ ...target }));
   }
 
+  async stopTerminal(action: CardAction): Promise<string> {
+    const ownerId = this.options.ownerId?.();
+    if (!ownerId || action.userId !== ownerId) throw new Error("仅 AgentBot 所有者可结束终端。");
+    const scheduleId = Number(action.value.scheduleId);
+    const terminalId = typeof action.value.terminalId === "string" ? action.value.terminalId : "";
+    if (!Number.isSafeInteger(scheduleId) || scheduleId <= 0 || !/^[a-f0-9]{32}$/u.test(terminalId)) {
+      throw new Error("安全重启卡片无效，请使用最新的状态卡片。");
+    }
+    if (scheduleId !== this.activeScheduleId || !this.options.isCurrentSchedule?.(scheduleId)
+      || !this.lastStatus || ["cancelled", "restarting"].includes(this.lastStatus.phase)
+      || !action.messageId || this.messageIds.get(action.contextKey) !== action.messageId
+      || !this.cardTerminalIds.get(action.contextKey)?.has(terminalId)) {
+      throw new Error("该安全重启卡片或终端操作已失效，请查看最新状态卡片。");
+    }
+    if (!this.options.stopTerminal) throw new Error("网页终端未启用。");
+    const stopped = await this.options.stopTerminal(terminalId, ownerId);
+    return stopped ? "已请求结束对应终端，安全重启将继续等待其余阻塞项。" : "该终端已结束或正在关闭，无需重复操作。";
+  }
+
   private publishPendingInitialStatus(): Promise<void> {
     this.clearInitialCardTimer();
     const status = this.pendingInitialStatus;
@@ -133,6 +157,8 @@ export class SafeRestartNotifier {
         remainingMs: status.remainingMs,
         pendingFinalDeliveries: status.activity.pendingFinalDeliveries,
         activeTerminals: status.activity.activeTerminals,
+        terminalBlockers: status.activity.terminalBlockers,
+        contextKey,
         waitingTasks,
       });
       const cardHash = JSON.stringify(card);
@@ -141,12 +167,17 @@ export class SafeRestartNotifier {
         if (this.cardHashes.get(contextKey) === cardHash) return;
         try {
           await this.outbound.updateInteractiveCard(messageId, card);
-          this.cardHashes.set(contextKey, cardHash);
+          if (this.activeScheduleId === status.scheduleId && this.messageIds.get(contextKey) === messageId) {
+            this.cardHashes.set(contextKey, cardHash);
+            this.cardTerminalIds.set(contextKey, new Set((status.activity.terminalBlockers ?? []).map((terminal) => terminal.terminalId)));
+          }
           return;
         } catch (error) {
           this.logger.warn({ error, contextKey, messageId }, "Failed to update safe restart status card; sending a replacement.");
+          if (this.activeScheduleId !== status.scheduleId) return;
           this.messageIds.delete(contextKey);
           this.cardHashes.delete(contextKey);
+          this.cardTerminalIds.delete(contextKey);
         }
       }
       try {
@@ -170,6 +201,7 @@ export class SafeRestartNotifier {
           if (this.activeScheduleId === status.scheduleId) {
             this.messageIds.set(contextKey, created);
             this.cardHashes.set(contextKey, cardHash);
+            this.cardTerminalIds.set(contextKey, new Set((status.activity.terminalBlockers ?? []).map((terminal) => terminal.terminalId)));
           } else {
             await this.stopCard(created, status, reason ?? status.reason);
           }

package/src/supervision/SafeRestartScheduler.ts

@@ -1,5 +1,8 @@
+import type { ActiveTerminal } from "../terminal/TerminalServer.js";
+
 export interface ServerActivityState {
   activeTerminals?: number;
+  terminalBlockers?: ActiveTerminal[];
   runningSessions: number;
   pendingFinalDeliveries: number;
   latestInboundAt?: string;
@@ -66,6 +69,10 @@ export class SafeRestartScheduler {
     return this.reason;
   }
 
+  isCurrentSchedule(scheduleId: number): boolean {
+    return this.scheduled && !this.restartingNow && this.scheduleId === scheduleId;
+  }
+
   schedule(
     reason: string,
     notificationTarget?: RestartNotificationTarget,

package/src/terminal/TerminalCommandTracker.ts

@@ -0,0 +1,74 @@
+import { randomBytes } from "node:crypto";
+
+export interface TerminalCommandState {
+  status: "unknown" | "idle" | "running";
+  command?: string;
+  source?: "shell" | "process";
+}
+
+export class TerminalCommandTracker {
+  readonly nonce = randomBytes(16).toString("hex");
+  private readonly prefix = String.fromCharCode(27) + "]777;agentbot;" + this.nonce + ";";
+  private pending = "";
+  private current: TerminalCommandState = { status: "unknown" };
+
+  snapshot(): TerminalCommandState { return { ...this.current }; }
+
+  consume(data: string): string {
+    this.pending += data;
+    let output = "";
+    while (this.pending) {
+      const start = this.pending.indexOf(this.prefix);
+      if (start < 0) {
+        let retained = Math.min(this.prefix.length - 1, this.pending.length);
+        while (retained && !this.prefix.startsWith(this.pending.slice(-retained))) retained--;
+        output += this.pending.slice(0, this.pending.length - retained);
+        this.pending = this.pending.slice(this.pending.length - retained);
+        break;
+      }
+      output += this.pending.slice(0, start); this.pending = this.pending.slice(start);
+      const end = this.pending.indexOf("\u0007", this.prefix.length);
+      if (end < 0 && this.pending.length <= 32_768) break;
+      if (end < 0 || end > 32_768) {
+        output += this.pending[0]; this.pending = this.pending.slice(1); continue;
+      }
+      const payload = this.pending.slice(this.prefix.length, end);
+      if (payload === "idle") this.current = { status: "idle", source: "shell" };
+      else if (payload.startsWith("command;") && /^[A-Za-z0-9+/]*={0,2}$/u.test(payload.slice(8))) {
+        const command = Buffer.from(payload.slice(8), "base64").toString("utf8")
+          .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/gu, "").trim();
+        this.current = { status: "running", source: "shell", command: command.slice(0, 2_000) || undefined };
+      } else this.current = { status: "unknown" };
+      this.pending = this.pending.slice(end + 1);
+    }
+    return output;
+  }
+}
+
+export function powerShellTrackingScript(nonce: string): string {
+  if (!/^[a-f0-9]{32}$/u.test(nonce)) throw new Error("Invalid terminal tracking nonce.");
+  // Wrap the accepted line, not the history hook (which skips duplicate commands).
+  // Leave editing/history policy intact and call the original prompt/readline before altering $?.
+  return [
+    "$global:__AgentBotPrompt = $function:prompt",
+    "$global:__AgentBotMarker = [char]27 + ']777;agentbot;" + nonce + ";'",
+    "try {",
+    "  Import-Module PSReadLine -ErrorAction Stop",
+    "  $global:__AgentBotReadLine = $function:PSConsoleHostReadLine",
+    "  if ($null -eq $global:__AgentBotReadLine) { throw 'PSConsoleHostReadLine unavailable' }",
+    "  function global:PSConsoleHostReadLine {",
+    "    $line = & $global:__AgentBotReadLine",
+    "    if (-not [string]::IsNullOrWhiteSpace($line)) {",
+    "      $text = if ($line.Length -gt 2000) { $line.Substring(0, 2000) } else { $line }",
+    "      [Console]::Write($global:__AgentBotMarker + 'command;' + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($text)) + [char]7)",
+    "    }",
+    "    return $line",
+    "  }",
+    "  function global:prompt {",
+    "    $text = & $global:__AgentBotPrompt",
+    "    [Console]::Write($global:__AgentBotMarker + 'idle' + [char]7)",
+    "    return $text",
+    "  }",
+    "} catch { [Console]::Write($global:__AgentBotMarker + 'unknown' + [char]7) }",
+  ].join("\n");
+}

package/src/terminal/TerminalProcess.ts

@@ -3,8 +3,11 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import type { IPty } from "node-pty";
+import { powerShellTrackingScript, TerminalCommandTracker, type TerminalCommandState } from "./TerminalCommandTracker.js";
 
-export type TerminalProcess = Pick<IPty, "write" | "resize" | "kill" | "onData" | "onExit">;
+export type TerminalProcess = Pick<IPty, "write" | "resize" | "kill" | "onData" | "onExit"> & {
+  commandState?(): TerminalCommandState;
+};
 export type TerminalSpawner = (cwd: string, cols: number, rows: number) => Promise<TerminalProcess>;
 
 export function terminalShell(
@@ -63,9 +66,28 @@ export const spawnTerminal: TerminalSpawner = async (cwd, cols, rows) => {
     prepareTerminalHelper(path.dirname(require.resolve("node-pty/package.json")));
   }
   const shell = terminalShell();
-  return pty.spawn(shell.file, shell.args, {
+  const tracker = new TerminalCommandTracker();
+  const powershell = /^(pwsh|powershell)(\.exe)?$/iu.test(path.basename(shell.file));
+  const args = powershell ? [...shell.args, "-NoExit", "-EncodedCommand",
+    Buffer.from(powerShellTrackingScript(tracker.nonce), "utf16le").toString("base64")] : shell.args;
+  const processPty = pty.spawn(shell.file, args, {
     cwd, cols, rows, name: "xterm-256color", env: terminalEnvironment(), useConpty: true,
     // The bundled ConPTY closes via its input pipe, avoiding node-pty's console-list helper on kill.
     useConptyDll: process.platform === "win32",
   });
+  return {
+    write: (data) => processPty.write(data), resize: (cols, rows) => processPty.resize(cols, rows), kill: () => processPty.kill(),
+    onExit: (listener) => processPty.onExit(listener),
+    onData: (listener) => processPty.onData((data) => { const visible = tracker.consume(data); if (visible) listener(visible); }),
+    commandState: () => {
+      const tracked = tracker.snapshot();
+      if (tracked.status !== "unknown" || process.platform === "win32") return tracked;
+      try {
+        const name = processPty.process;
+        // Unix PTYs can report a foreground process even without shell integration.
+        if (name && path.basename(name) !== path.basename(shell.file)) return { status: "running", command: name, source: "process" };
+      } catch { /* An exited PTY may no longer have a foreground process. */ }
+      return tracked;
+    },
+  };
 };

package/src/terminal/TerminalServer.ts

@@ -12,6 +12,7 @@ import type { CardAction } from "../feishu/types.js";
 import { spawnTerminal, type TerminalProcess, type TerminalSpawner } from "./TerminalProcess.js";
 import { terminalPage, TERMINAL_CSS, TERMINAL_SCRIPT } from "./TerminalPage.js";
 import { TerminalLinks } from "./TerminalLinks.js";
+import type { TerminalCommandState } from "./TerminalCommandTracker.js";
 
 const require = createRequire(import.meta.url);
 const AUTH_TTL = 5 * 60_000;
@@ -36,6 +37,11 @@ export interface TerminalCardView extends TerminalAuthorization {
   terminalId: string; reopenToken: string; reopenUrl: string; recovery: boolean; state: "pending" | "approved" | "running" | "closed";
   connected: boolean; message?: string;
 }
+export interface ActiveTerminal {
+  terminalId: string; token: string; cwd: string;
+  state: "starting" | "running" | "closing"; connected: boolean;
+  active: boolean; foreground: boolean; command: TerminalCommandState;
+}
 export interface TerminalServerOptions {
   stateDirectory: string;
   ownerId(): string | undefined;
@@ -133,6 +139,37 @@ export class TerminalServer {
     return [...this.sessions.values()].filter((s) => s.pty || s.starting).length;
   }
 
+  listActiveTerminals(): ActiveTerminal[] {
+    return [...this.sessions.values()].filter((s) => s.pty || s.starting).map((s) => {
+      const foreground = s.socket?.readyState === WebSocket.OPEN && (s.foregroundUntil ?? 0) > this.now();
+      let command: TerminalCommandState = { status: "unknown" };
+      if (s.state !== "closed") {
+        try { command = s.pty?.commandState?.() ?? command; }
+        catch { /* Command inspection must not prevent safe-restart activity checks. */ }
+      }
+      return {
+        terminalId: s.requestId, token: s.reopenToken, cwd: s.cwd,
+        state: s.state === "closed" ? "closing" : s.pty ? "running" : "starting",
+        connected: s.socket?.readyState === WebSocket.OPEN,
+        active: s.state !== "closed" && (foreground || command.status === "running" || this.now() - s.lastActivity < 30_000),
+        foreground, command,
+      };
+    });
+  }
+
+  async stopActiveTerminal(terminalId: string, userId: string): Promise<boolean> {
+    const ownerId = this.options.ownerId();
+    if (!ownerId || userId !== ownerId) throw new Error("仅 AgentBot 所有者可结束终端。");
+    const session = this.sessions.get(terminalId);
+    if (!session || session.state === "closed" || (!session.pty && !session.starting)) return false;
+    if (session.ownerId !== userId) throw new Error("终端所有者已变更，请刷新状态。");
+    // Keep blocking restart if the OS refuses to terminate the Shell.
+    if (session.pty) session.pty.kill();
+    this.disposeSession(session, "所有者已从安全重启卡片结束终端", true);
+    await this.cardUpdates;
+    return true;
+  }
+
   async resolveApproval(action: CardAction): Promise<string> {
     this.sweep();
     const id = String(action.value.requestId ?? "");
@@ -425,11 +462,13 @@ export class TerminalServer {
     this.assertCanStart();
     const starting = (async () => {
       const pty = await (this.options.spawn ?? spawnTerminal)(session.cwd, 100, 30);
+      session.pty = pty;
+      pty.onExit(({ exitCode }) => { session.pty = undefined; this.disposeSession(session, `Shell 已退出（${exitCode}）`); });
       if (this.closed || this.options.canStart?.() === false || session.state === "closed"
         || session.ownerId !== this.options.ownerId() || this.now() >= session.expiresAt) {
-        pty.kill(); this.disposeSession(session, "服务正在重启或授权已失效"); return;
+        this.disposeSession(session, "服务正在重启或授权已失效", true); pty.kill(); return;
       }
-      session.pty = pty; session.state = "running"; session.lastActivity = this.now();
+      session.state = "running"; session.lastActivity = this.now();
       this.markDisconnected(session);
       pty.onData((data) => {
         if (session.state !== "running") return;
@@ -437,7 +476,6 @@ export class TerminalServer {
         session.output = (session.output + data).slice(-256 * 1024);
         if (session.socket) this.send(session.socket, { type: "data", data });
       });
-      pty.onExit(({ exitCode }) => { session.pty = undefined; this.disposeSession(session, `Shell 已退出（${exitCode}）`); });
       this.options.logger.info({ requestId: session.requestId }, "Interactive terminal started.");
     })();
     session.starting = starting;
@@ -469,16 +507,16 @@ export class TerminalServer {
       if (s.state === "running" && now - Math.max(s.lastActivity, s.foregroundUntil ?? 0) >= IDLE_TTL) {
         this.disposeSession(s, "连续 30 分钟无输入或输出，Shell 已自动关闭");
       }
-      if (s.state === "closed" && !s.starting && now - s.lastActivity >= AUTH_TTL) this.sessions.delete(s.requestId);
+      if (s.state === "closed" && !s.pty && !s.starting && now - s.lastActivity >= AUTH_TTL) this.sessions.delete(s.requestId);
     }
   }
-  private disposeSession(s: TerminalSession, message: string): void {
+  private disposeSession(s: TerminalSession, message: string, waitForExit = false): void {
     if (s.state === "closed") return;
     this.clearDisconnectTimer(s);
     s.state = "closed"; s.message = message; s.lastActivity = this.now();
-    const pty = s.pty; s.pty = undefined;
+    const pty = s.pty; if (!waitForExit) s.pty = undefined;
     if (s.socket) { this.send(s.socket, { type: "exit", message }); s.socket.close(); s.socket = undefined; }
-    try { pty?.kill(); } catch (error) { this.options.logger.warn({ error, requestId: s.requestId }, "Failed to close terminal process."); }
+    try { if (!waitForExit) pty?.kill(); } catch (error) { this.options.logger.warn({ error, requestId: s.requestId }, "Failed to close terminal process."); }
     s.output = "";
     for (const recovery of this.recoveries.values()) {
       if (recovery.targetId === s.requestId) this.closeRecovery(recovery, message);