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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.24-alpha.6",
+  "version": "0.1.24-alpha.8",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",

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
 
@@ -137,9 +137,9 @@ A successful Provider switch confirms settings, not inference connectivity. Mode
 
 Providers such as a Responses bridge may omit assistant message phases. Unphased text stays in the progress timeline; successful completion promotes only the last message not followed by a tool start. Do not diagnose progress text in the answer area as a CSS issue without checking message phases. Old snapshots are not automatically backfilled.
 
-Provider changes during an Agent Bot turn are staged until it ends; do not stop the turn. The settings card and CLI show the pending Provider/model, and model/thinking/permission selections edit that pending configuration. The latest selection is applied before the next turn, including queued/retried turns. Pending settings survive restart, remain separate from actual task settings, and are verified before saving Agent defaults. Deferred failures roll back to the original Provider/model. After the runtime confirms rollback, the card returns to the original settings, the pending selection is cleared, and queued prompts continue with the original settings. Failed or unverified rollback still pauses queued prompts and requires explicit recovery; never claim rollback success based only on unchanged local fields. Custom Providers discover models through their OpenAI-compatible `/models` endpoint when available. Switching keeps the previous model when supported, otherwise uses the Provider default or its first model. A missing model-list endpoint falls back to the current or configured model and does not by itself block switching. Wait for active work to finish; do not stop it without the user's request. Switching unloads only the selected thread, not the shared App Server. On failure, previous settings are retained and recovery is attempted. If recovery fails, resolve the reported configuration or ownership issue and retry the Provider switch before sending another prompt. Never replace a forked task with an empty task to work around a switch failure.
+Provider changes during an Agent Bot turn are staged until it ends; do not stop the turn. The settings card and CLI show the pending Provider/model, and model/thinking/permission selections edit that pending configuration. The latest selection is applied before the next turn, including queued/retried turns. Pending settings survive restart, remain separate from actual task settings, and are verified before saving Agent defaults. Deferred failures roll back to the original Provider/model. After the runtime confirms rollback, the card returns to the original settings, the pending selection is cleared, and queued prompts continue with the original settings. Failed or unverified rollback still pauses queued prompts and requires explicit recovery; never claim rollback success based only on unchanged local fields. Custom Providers discover models through their OpenAI-compatible `/models` endpoint when available. Switching keeps the previous model when supported, otherwise uses the Provider default or its first model. A missing model-list endpoint falls back to the current or configured model and does not by itself block switching. Wait for active work to finish; do not stop it without the user's request. Switching detaches only the selected thread and waits for its actual unload before resuming. On failure, previous settings are retained and recovery is attempted. If recovery fails, resolve the reported configuration or ownership issue and retry the Provider switch before sending another prompt. Never replace a forked task with an empty task to work around a switch failure.
 
-Provider changes must keep the same remote task ID and complete history. Never use Fork, thread replacement, synthetic Turns, or history repair to change settings. A rejected switch must report the reason and verify rollback; if App Server retains a stale Provider, suggest an explicit safe restart and retry rather than restarting the shared process implicitly. Settings inspection and selection must remain available when the old Provider cannot resume.
+Provider changes must keep the same remote task ID and complete history. Never use Fork, thread replacement, synthetic Turns, or history repair to change settings. A rejected switch must report the reason and verify rollback; Codex is started with zero thread-unload delay, and switching waits for the selected thread to report notLoaded before resuming it. Other tasks may remain active, and empty sibling tasks stay untouched. An unload timeout does not prove external ownership; inspect the selected task and retry after releasing any remaining subscription. Do not restart or force-release the shared process to switch Provider. Settings inspection and selection must remain available when the old Provider cannot resume.
 
 ## Goals And Turns
 
@@ -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.
@@ -221,7 +223,7 @@ agentbot --profile ~/.agent-bot-rescue server status
 
 Initialization prepares configuration, checks supported Agents, configures Feishu, and starts the server. On first initialization and `init --reset`, let the user choose whether all group messages are accepted or an explicit @ mention is required; only the first choice requests the additional all-group-message permission. Relay authorization links and wait for the user; never choose a response mode, skip authorization, or choose maintenance actions without permission.
 
-Codex requires version 0.153.4 or later. Init checks this locally, and runtime startup validates the actual App Server version. For an unsupported version, show the upgrade instruction (`codex update` or `npm install -g @openai/codex@latest`); do not work around it by reading full history through legacy APIs. Safely restart Agent Bot after an authorized upgrade. This version requirement does not apply to TraeX or ACP Agents.
+Codex requires version 0.162.1 or later. Init checks this locally, and runtime startup validates the actual App Server version. For an unsupported version, show the upgrade instruction (`codex update` or `npm install -g @openai/codex@latest`); do not work around it by reading full history through legacy APIs. Safely restart Agent Bot after an authorized upgrade. This version requirement does not apply to TraeX or ACP Agents.
 
 Use `init --reset` only for an explicitly requested full reset. Without `--profile` it resets the default Profile; pass `--profile <directory>` to reset another Profile. It preserves backups under `.reset-backups`.
 

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/CodexProcessManager.ts

@@ -60,9 +60,11 @@ export class CodexProcessManager implements AppServerClientProvider {
     const environmentContext = this.environmentContext();
     const agentEnvironment = { ...this.env };
     if (this.getAgentFamily() === "codex") agentEnvironment.CODEX_HOME = this.getCodexHome();
+    const args = this.getAgentFamily() === "codex"
+      ? [...this.args, "-c", "thread_unload_delay_secs=0"] : this.args;
     const child = spawnStdioCommand(
       this.command,
-      this.args,
+      args,
       agentBotEnvironment({ ...this.codexEnvironment, ...process.env }, agentEnvironment, environmentContext),
       environmentContext.profilePath ?? os.homedir(),
     );

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;
@@ -829,7 +832,7 @@ export class CodexRuntime implements AgentRuntime {
   ): Promise<RuntimeSession> {
     const session = this.requireSession(sessionId);
     if (session.activeTurnId) throw new Error(PROVIDER_SWITCH_BUSY);
-    const client = await this.client();
+    let client = await this.client();
     const metadata = await client.request<ThreadReadResponse>("thread/read", {
       threadId: session.remoteSessionId, includeTurns: false,
     }, SYNC_REQUEST_TIMEOUT_MS);
@@ -851,12 +854,14 @@ export class CodexRuntime implements AgentRuntime {
     const restoreProvider = previous.modelProvider?.trim()
       || (metadata.thread.id === previous.remoteSessionId ? metadata.thread.modelProvider?.trim() : undefined);
     let detached = false;
+    let resumeRequested = false;
     try {
       const params = {
         cwd: session.cwd, modelProvider: settings.modelProvider, model: settings.model,
         ...threadLifecycleParams(session.cwd), ...permissionParams(settings.permissionMode),
       };
       await this.detachThreadForSettings(client, session, () => { detached = true; });
+      resumeRequested = true;
       const response = await client.request<ThreadResponse>("thread/resume", {
         ...params, threadId: session.remoteSessionId, excludeTurns: true,
       }, SESSION_REQUEST_TIMEOUT_MS);
@@ -877,7 +882,8 @@ export class CodexRuntime implements AgentRuntime {
       if (detached) {
         try {
           if (!restoreProvider) throw new Error("无法确认切换前的 Provider，不能验证原设置已恢复。");
-          await this.detachThreadForSettings(client, previous);
+          client = await this.client();
+          if (resumeRequested) await this.detachThreadForSettings(client, previous);
           const restored = await client.request<ThreadResponse>("thread/resume", {
             threadId: previous.remoteSessionId, excludeTurns: true, cwd: previous.cwd,
             modelProvider: restoreProvider, model: previous.model,
@@ -918,6 +924,20 @@ export class CodexRuntime implements AgentRuntime {
     if (!["unsubscribed", "notLoaded", "notSubscribed"].includes(result.status)) {
       throw new Error(`App Server 返回了未知的取消订阅状态：${result.status}`);
     }
+    if (this.provider.getAgentFamily?.() === "codex") {
+      const deadline = Date.now() + CONTROL_REQUEST_TIMEOUT_MS;
+      while (Date.now() < deadline) {
+        if (this.attachedClient !== client) throw new Error("App Server 连接已变化，请重试 Provider 切换。");
+        const { thread } = await client.request<ThreadReadResponse>("thread/read", {
+          threadId: session.remoteSessionId, includeTurns: false,
+        }, Math.min(SYNC_REQUEST_TIMEOUT_MS, Math.max(1, deadline - Date.now())));
+        if (thread.id !== session.remoteSessionId) throw new Error("App Server 返回了不同的任务 ID，未切换 Provider。");
+        if (thread.status?.type === "notLoaded") return;
+        if (thread.status?.type === "active" || session.activeTurnId) throw new Error(PROVIDER_SWITCH_BUSY);
+        await delay(100);
+      }
+      throw new Error("等待任务卸载超时；任务可能仍有订阅或正在关闭，请稍后重试 Provider 切换。");
+    }
   }
 
   async respondToApproval(
@@ -950,11 +970,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 +998,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 +1271,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 +1291,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/CodexVersion.ts

@@ -1,7 +1,7 @@
 import { compareSemanticVersions } from "../utils/semanticVersion.js";
 
-// Verified protocol baseline: paginated Turn summaries and excludeTurns.
-export const MINIMUM_CODEX_VERSION = "0.153.4";
+// Verified protocol baseline: paginated history and configurable thread unloading.
+export const MINIMUM_CODEX_VERSION = "0.162.1";
 
 export class CodexVersionError extends Error {}
 

package/src/codex/ProviderSwitch.ts

@@ -15,7 +15,7 @@ export function assertProviderSettingsApplied(
   requested: Partial<Pick<RuntimeExecutionSettings, "modelProvider" | "model">>,
 ): void {
   if (requested.modelProvider !== undefined && actual.modelProvider !== requested.modelProvider) {
-    throw new Error(`Provider 未生效：请求 ${requested.modelProvider}，实际返回 ${actual.modelProvider ?? "未知"}。App Server 未应用设置；可在任务空闲后安全重启再重试，不会自动 Fork 或更改历史。`);
+    throw new Error(`Provider 未生效：请求 ${requested.modelProvider}，实际返回 ${actual.modelProvider ?? "未知"}。App Server 未应用设置，请稍后重试；不会自动 Fork 或更改历史。`);
   }
   if (requested.model !== undefined && actual.model !== requested.model) {
     throw new Error(`模型未生效：请求 ${requested.model}，实际返回 ${actual.model ?? "未知"}。请确认目标 Provider 支持该模型。`);

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");
+}