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

package/docs/technical-reference.zh.md

@@ -35,7 +35,7 @@ Agent Bot 是基于 Node.js 22+、ESM 和 TypeScript 的应用，主要组件如
 
 CLI 还支持显式指定目录的 Profile。不使用 `--profile` 时，命令使用主 Profile 以及原有的环境变量路径规则。`--profile <目录>` 会为当前命令及其启动的 Supervisor、Worker 固定 `AGENT_BOT_HOME` 和 `AGENT_BOT_CONFIG`，配置文件固定为 `<目录>/config.yaml`。它还会先清除继承的飞书凭据环境变量，再加载所选 Profile 的 `.env`，避免从主 Agent Bot 进程树中启动辅助实例时误用主机器人的凭据。`--profile` 不能和 `--config` 同时使用。其他 Profile 必须在每次命令中显式选择；Agent Bot 不维护按名称注册的 Profile。
 
-CLI 通过 Node.js 国际化能力读取系统 Locale。以 `zh` 开头的 Locale 使用中文界面；英文及所有未支持 Locale 使用英文。帮助、状态、进度、交互提示和 CLI 自身错误都遵循此规则；JSON 字段名及枚举值不做本地化。系统生成的重启原因仍使用中文，因为它会显示在中文 Lark 状态卡中；显式传入的 `--reason` 保持原样。`agentbot server status` 会报告运行中 Worker 的 Lark App ID，JSON 字段名为 `feishuAppId`；服务停止或旧版健康协议尚未提供该字段时，CLI 会回退到当前 Profile 配置的 App ID。
+CLI 通过 Node.js 国际化能力读取系统 Locale。以 `zh` 开头的 Locale 使用中文界面；英文及所有未支持 Locale 使用英文。帮助、状态、进度、交互提示和 CLI 自身错误都遵循此规则；JSON 字段名及枚举值不做本地化。系统生成的重启原因仍使用中文，因为它会显示在中文 Lark 状态卡中；显式传入的 `--reason` 保持原样。`agentbot server status` 会报告运行中 Worker 的 Lark App ID，JSON 字段名为 `feishuAppId`；服务停止或旧版健康协议尚未提供该字段时，CLI 会回退到当前 Profile 配置的 App ID。`agents` 数组会报告每个已配置 Agent 进程的 PID 和协议初始化返回的版本号；Agent 尚未启动时两者均为 `null`。
 
 | 默认路径                             | 内容                 |
 | ------------------------------------ | -------------------- |
@@ -73,6 +73,7 @@ CLI 通过 Node.js 国际化能力读取系统 Locale。以 `zh` 开头的 Local
 - 进程环境变量优先于 `~/.agent-bot/.env`
 - `FEISHU_APP_ID` 和 `FEISHU_APP_SECRET` 必须同时存在
 - 一键注册还会把授权用户的 `open_id` 保存为 `FEISHU_USER_OPEN_ID`
+- 已有应用凭据但缺少用户 Open ID 时，第一条发送者为有效 `ou_` 标识的私聊消息会把该用户原子写入 Profile 的 `.env`；群消息和后续用户都不会覆盖它
 - 除非使用 `--reconfigure-feishu`，完整凭据不会被替换
 - 缺少凭据或只有一项时会重新创建应用
 - 新创建的凭据经过 fsync、原子替换写入 `.env`，并在配置权限前读回校验
@@ -100,7 +101,7 @@ https://open.feishu.cn/app/<appId>/auth?q=im%3Amessage.group_msg&op_from=openapi
 
 `agentbot --profile <目录> init --reset` 会完整重置显式指定的 Profile。执行前必须先停止该 Profile 的 Server。命令会把当前 `config.yaml`、`.env`、`data/` 和 `logs/` 移入 `<profile>/.reset-backups/` 下唯一的时间戳目录，从随包模板创建干净的新文件和目录，再继续正常初始化。已有重置备份及其他无关文件会保留。备份中可能含有旧 App Secret 和会话数据，应妥善保护 Profile 目录。远端旧飞书应用不会被删除。`--reset --skip-feishu` 可创建干净的 Console-only Profile，`--reset` 不能与 `--reconfigure-feishu` 同时使用。
 
-飞书初始化成功后，CLI 会先释放初始化锁，再通过与 `agentbot server start` 相同的就绪检查流程启动后台 Supervisor，并等待最多 45 秒，直到 Worker 连接飞书并进入就绪状态。如果当前 Profile 的服务已经运行，不会创建第二个 Supervisor。`--skip-feishu` 会跳过自动启动；`--json` 会把结果写入 `server.status`，不会混入非 JSON 文本。
+飞书初始化成功后，CLI 会先释放初始化锁，再通过与 `agentbot server start` 相同的就绪检查流程启动后台 Supervisor，并等待最多 45 秒，直到 Worker 连接飞书并进入就绪状态。如果当前 Profile 的服务已经运行，不会创建第二个 Supervisor，而是安排安全重启，在活动任务和最终结果投递完成后加载当前安装的代码及更新后的配置；JSON 结果将其表示为 `server.status: "restart-scheduled"`。`--skip-feishu` 会跳过自动启动；`--json` 会把结果写入 `server.status`，不会混入非 JSON 文本。
 
 ## 飞书应用要求
 
@@ -171,7 +172,7 @@ logging:
 
 `feishu.respondToAllGroupMessages` 默认为 `true`。设为 `false` 后，未 @ 当前机器人的群消息会被忽略；Worker 启动时会解析机器人的 Open ID，因此 @ 其他成员不会误触发。私聊始终正常处理。无论该运行时配置如何，初始化都会申请接收全部群消息的权限，之后切换配置无需再次授权。
 
-`agentbot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。每张启动卡片都会显示从已安装包元数据读取的 Agent Bot 版本。通知通常发往已知私聊和最近活跃的群聊；数据库里尚无已知会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续。缺少凭据时仍会启动失败并提示先初始化。`agentbot console` 是明确的纯本地入口，不需要飞书凭据。
+`agentbot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。每张启动卡片都会显示从已安装包元数据读取的 Agent Bot 版本。每次启动都会向所有已知私聊发送卡片，不受最近活跃时间影响；同时向本次 Worker 启动前 1 分钟内活跃的非话题群聊发送卡片。安全重启后，还会向所有已加入本次重启通知范围的群发送，不受活跃时间限制；话题路由会折算为所属普通群，因此话题会话永远不会成为启动卡目标。数据库里尚无符合条件的会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续；之后收到的第一条私聊消息可以补全用户 Open ID，供后续启动通知和 CLI 建群使用。缺少凭据时仍会启动失败并提示先初始化。`agentbot console` 是明确的纯本地入口，不需要飞书凭据。
 
 必须至少配置一个 Agent，`defaults.agent` 必须指向已配置的 Agent。
 
@@ -183,13 +184,19 @@ Agent 配置的标准名是运行时隔离键。每个配置的 Agent 都拥有
 
 `kind: "acp"` 或未填写 `kind` 的 Agent 使用各自的 ACP 进程。同一 Agent 的多个任务会在该连接上创建独立 ACP session。Agent 配置中的 `env` 只会加入该 Agent 的环境变量。
 
-所有 Agent 子进程都会收到：
+Agent 进程会继承普通父进程变量。启动 App Server 或 ACP 进程前，Agent Bot 会移除继承环境及 Agent 配置中名称不区分大小写匹配 `FEISHU_*` 或 `AGENT_BOT_*` 的全部变量，然后注入以下受控的非敏感上下文：
 
 ```text
 AGENT_BOT=1
+AGENT_BOT_HOME=<当前 Profile 根目录>
+AGENT_BOT_CONFIG=<当前 config.yaml 路径>
+AGENT_BOT_AGENT_NAME=<Agent 配置标准名>
+AGENT_BOT_LARK_APP_ID=<Lark App ID>
+AGENT_BOT_LARK_BOT_OPEN_ID=<Lark 机器人 open_id，可用时提供>
+AGENT_BOT_LARK_USER_OPEN_ID=<已保存的授权用户 open_id，可用时提供>
 ```
 
-内置 Skill 使用该环境变量判断自己是否运行在 Agent Bot 中。
+内置 Skill 使用 `AGENT_BOT` 判断自己是否运行在 Agent Bot 中。Lark App Secret、Supervisor 状态、重启原因和重启通知路由不会传给 Agent。`agents.<name>.env` 中不使用保留命名空间的变量，仍是显式配置该 Agent 专用环境的方式。
 
 ## 聊天路由
 
@@ -222,13 +229,15 @@ Agent Bot 会在每个 `thread/fork` 请求中默认发送实验性的 `excludeT
 
 每个 turn 只有一张进度卡。普通更新最多每两秒一次，关键更新最短间隔 500 毫秒。完成时先把进度卡更新为终态，再单独发送 Markdown 最终回答。
 
+成功完成的思考卡片包含 `Reset` 操作，其作用提示紧跟在按钮下方。`/turns` 卡片把相同的作用提示放在最上方，然后按时间倒序显示当前任务的已完成 turn，每页 10 条。每次 `turn_started` 都会把前一个已完成 turn 保存为父节点；现有任务会结合快照时间和 `session_reset_to_turn` 审计记录回填，因此历史 Reset 后的第一轮会指向所选 turn，而不是时间上相邻的废弃路径。渲染器先基于完整历史计算 lane，再切分页面，从而跨分页正确显示延续和合并；内容缩进到第二列，状态或操作位于第三列。当前对话位置显示“当前”标记，其余 turn 提供 `Reset` 按钮。翻页和成功的 Reset 都会更新同一张卡片、保持与打开卡片时的任务绑定，并把“当前”标记移动到所选 turn；成功提示会用 Prompt 摘要、完成时间和 Turn ID 标明目标轮次。Agent Bot 会持久化每个 turn 原本所属的 App Server thread，从所选 turn fork，并替换当前任务的远端 thread 绑定；本地任务 ID、标题、Agent、项目目录、运行设置和聊天路由保持不变。所选 turn 之后已经完成的快照不会被删除，因此卡片会同时显示旧路径保留的轮次和 Reset 后新分支产生的轮次。当前任务仍在执行时会拒绝 Reset，本地文件修改也不会被回退。
+
 完成持久化消息去重占位后，Agent Bot 会等待 `OnIt` 表情添加成功，再进行聊天信息持久化、图片下载、队列等待、命令执行或 Runtime 调用。Turn 成功、失败或取消时分别替换为 `DONE`、`ERROR` 或 `CrossMark`。表情操作失败会记录日志，但不会阻塞任务。
 
 富文本图片会下载到输入图片缓存，并以 `localImage` 传给 App Server。纯图片消息使用默认 Prompt `请查看这张图片`。ACP Runtime 不支持图片输入时会明确报错。
 
 ## 任务、项目与外部 App Server 工作
 
-`/sessions` 通过 `thread/list` 读取每个已配置 App Server Agent 的任务。对于 Codex，可发现同一 `CODEX_HOME` 下由 Codex Desktop、CLI、Agent Bot 或其他 App Server 客户端创建的任务；其他 Agent 通过同一协议暴露各自的任务存储。
+`/sessions` 通过 `thread/list` 读取每个已配置 App Server Agent 的任务。对于 Codex，可发现同一 `CODEX_HOME` 下由 Codex Desktop、CLI、Agent Bot 或其他 App Server 客户端创建的任务；其他 Agent 通过同一协议暴露各自的任务存储。多 Agent 任务合并并全局排序后，每页显示 5 个；`Previous` 和 `Next` 会替换当前卡片内容而不是继续追加任务，同时保留搜索条件和全局任务序号。
 
 每个任务条目都提供 `NewGroup` 和 `ForkGroup` 回调。回调数据保留所选任务 ID 与来源上下文，并使用飞书操作者的 `open_id` 邀请用户进入新群。`NewGroup` 解析所选任务的项目和执行设置；`ForkGroup` 解析该任务最新可用的已完成 turn。
 
@@ -290,9 +299,13 @@ Supervisor、Worker、替换 Supervisor 和 Console Worker 默认启用 Node fat
 
 飞书 `/restart` 命令默认使用这条安全重启路径；`/restart --force` 会立即重启，并可能中断正在执行的任务。该命令拒绝其他所有参数。新消息会重置静默计时，CLI 的 `--immediate` 和 `--force` 也会跳过这些检查。退出码 `75` 表示主动 worker 重启。
 
+待执行的安全重启计划会收集每一个触发它的精确会话路由。收到任何用户消息时，包括斜杠命令，都会把所属基础私聊或群聊标为活跃；每次状态更新还会加入此前 1 分钟内活跃的所有已知会话。每个已加入的会话都会收到各自的状态卡片和真正开始重启前的提示，而且即使之后超过 1 分钟未活跃，也会一直保留到本次计划结束。同一路由会去重；如果话题路由最初缺少消息锚点，后续带锚点的触发会补全它。话题请求会保留原消息 ID，并通过话题回复发送，避免重启状态落到群主会话；话题中的最近活动记在所属普通群，只有显式从话题触发时才向该话题本身发送。后续请求也会更新重启原因。替换进程前，Agent Bot 会提取并去重所有已加入路由所属的普通群，经替换 Supervisor 传给 Worker，再把这些群加入服务级启动卡目标。Supervisor 会保留该列表，直到 Worker 连续稳定运行 60 秒，避免启动阶段异常退出并重新拉起时丢失必发群。
+
+当 CLI 重启属于某个具体任务时，使用 `agentbot server restart --task <任务>`。任务序号、完整 ID 和不冲突的 ID 前缀会在发送控制请求前解析。未传 `--task` 时，只有所有运行中任务都属于同一个会话，Server 才会自动推断安全重启状态的发送目标；如果同时有多个运行中的会话，请求会被拒绝。没有运行中任务的本地 CLI 重启没有等待状态所属会话。
+
 首次安全重启状态卡会延迟 3 秒发送，让任务最终回答尽可能先到达；延迟期间的状态变化会合并到首张卡片。该延迟不阻塞调度器轮询，真正关闭前会立即 flush 尚未发送的卡片。
 
-等待中的安全重启状态卡底部带有 `Cancel` 操作。回调会携带调度器单调递增的计划 ID，因此旧卡片不会取消较新的重启。取消成功后，所有已发送的状态卡都会原地更新并移除按钮；调度器进入不可逆的正在重启阶段后也不再显示该按钮。
+等待中的安全重启状态卡底部带有 `Cancel` 操作。回调会携带调度器单调递增的计划 ID，因此旧卡片不会取消较新的重启。取消成功后，所有已加入会话中的状态卡都会原地更新并移除按钮；调度器进入不可逆的正在重启阶段后也不再显示该按钮。
 
 本地控制服务负责修改任务、执行指定任务的 NewGroup 和 ForkGroup，以及请求服务重启；只读任务查询直接访问 SQLite。
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.13-alpha.0",
+  "version": "0.1.13-alpha.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.13-alpha.0",
+      "version": "0.1.13-alpha.2",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

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

package/skills/agent-bot/SKILL.md

@@ -31,6 +31,19 @@ running_in_agent_bot = os.environ.get("AGENT_BOT") == "1"
 
 Treat this environment marker as authoritative. Do not infer Agent Bot execution merely because the CLI is installed, `~/.agent-bot` exists, or an Agent Bot process is running elsewhere. Configured agent environment variables cannot override the marker. Child processes normally inherit it, so the marker identifies the Agent Bot-started process tree unless a child explicitly replaces its environment.
 
+Agent Bot preserves ordinary parent-process variables but removes inherited and Agent-configured `FEISHU_*` and `AGENT_BOT_*` variables before starting an Agent. It then exposes only this controlled, non-secret context when values are available:
+
+```text
+AGENT_BOT_HOME
+AGENT_BOT_CONFIG
+AGENT_BOT_AGENT_NAME
+AGENT_BOT_LARK_APP_ID
+AGENT_BOT_LARK_BOT_OPEN_ID
+AGENT_BOT_LARK_USER_OPEN_ID
+```
+
+`AGENT_BOT_HOME` is the active Profile root. Never expect `FEISHU_APP_SECRET`, Supervisor state, restart reasons, or restart notification routes in the Agent environment.
+
 ## Behave safely inside Agent Bot
 
 When `AGENT_BOT=1`:
@@ -52,7 +65,9 @@ After the maintenance choice, interactive initialization requires the user to se
 
 Initialization creates the Agent Bot home, `config.yaml`, `.env`, `data/`, and `logs/` from the bundled examples. If Feishu credentials are absent, it starts Feishu one-click app registration, prints a QR code followed by its authorization URL, waits for the user to approve the request, and stores the returned app ID and secret in `.env`. It then audits the app's currently published tenant permissions, event subscriptions, and callbacks. Core and optional missing items produce separate configuration challenges. Core configuration is polled until ready, except that the manually configured all-group-message permission may be explicitly skipped with `Y`. For optional configuration, the CLI prints the QR code followed by the authorization URL and immediately waits up to five minutes for activation. The only terminal choice is also `Y`, which skips optional authorization and continues initialization.
 
-Rerun `agentbot init` after upgrading Agent Bot. It non-destructively upgrades an existing `config.yaml` by adding settings missing from the current bundled template while preserving user values, comments, custom Agents, and intentionally omitted template Agents. It also appends active variables missing from the bundled `.env.example` without changing existing values, comments, line endings, or enabling commented optional variables. It repeats the Agent version checks and Feishu configuration audit. Invalid YAML is left untouched and reported as an error. Use `init --reset` only for an explicitly requested full Profile reset.
+An existing app may have complete credentials but no `FEISHU_USER_OPEN_ID`. In that state, ask the user to send the bot a direct message. Agent Bot atomically persists the first valid private-chat sender to the Profile `.env`; group messages and later users cannot replace it. This identity is needed for startup-notification fallback and CLI-created group invitations.
+
+Rerun `agentbot init` after upgrading Agent Bot. It non-destructively upgrades an existing `config.yaml` by adding settings missing from the current bundled template while preserving user values, comments, custom Agents, and intentionally omitted template Agents. It also appends active variables missing from the bundled `.env.example` without changing existing values, comments, line endings, or enabling commented optional variables. It repeats the Agent version checks and Feishu configuration audit. If the selected Profile server is already running, initialization schedules a safe restart so the current installed code and refreshed configuration take effect after active work finishes. Invalid YAML is left untouched and reported as an error. Use `init --reset` only for an explicitly requested full Profile reset.
 
 Core messaging configuration includes `im:message.group_msg`, not merely the narrower group-mention scope. Accept `im:message.group_msg:readonly` when an existing app version reports that alias. Feishu cannot add `im:message.group_msg` through the one-click launcher, so Agent Bot excludes it from `addons` and prints a QR code plus a direct filtered Developer Console permission-page URL. The user should add the permission manually, publish the app version, and complete tenant approval if required. Entering `Y` skips only this permission wait and continues with a partial configuration; the bot then cannot respond to ordinary group messages that do not mention it.
 
@@ -86,7 +101,7 @@ agentbot server status
 agentbot task list
 ```
 
-Agent Bot CLI interface text follows the system locale: locales beginning with `zh` use Chinese, while English and unsupported locales use English. JSON output is not localized. `agentbot server status` also reports the running profile's Lark App ID; with `--json`, read it from `feishuAppId`.
+Agent Bot CLI interface text follows the system locale: locales beginning with `zh` use Chinese, while English and unsupported locales use English. JSON output is not localized. `agentbot server status` reports the running profile's Lark App ID and each configured Agent process's PID and initialized version. With `--json`, read them from `feishuAppId` and `agents`; an Agent that has not started has `null` process fields.
 
 Add `--json` to status and list commands when machine-readable output helps. If `agentbot` is unavailable, report that the CLI is not installed or linked instead of guessing process state.
 
@@ -99,12 +114,14 @@ Use these commands:
 ```powershell
 agentbot server start
 agentbot server status
-agentbot server restart --reason "reason for restart"
+agentbot server restart --task <current-task-id> --reason "reason for restart"
 agentbot server stop
 ```
 
 Treat `server restart` as the normal restart path. It schedules a safe restart and waits for active tasks, pending final-message delivery, and a quiet inbound-message window. The first safe-restart status card is delayed by three seconds so the active task's final response can usually be delivered first; this presentation delay does not postpone scheduler polling. While the restart is pending, its status card has a bottom `Cancel` button that conditionally cancels that exact schedule and updates the card in place.
 
+When scheduling from an Agent Bot-hosted task, pass `--task <current-task-id>`. This adds the task's exact Lark conversation, including its topic, to the pending restart's notification set. Every conversation that triggers the same pending restart plus every conversation active during the previous minute receives its own status card and restarting acknowledgement. Once enrolled, a route remains in the set until that restart ends; repeated routes are deduplicated. Resolve the current ID with `agentbot task list --status running` when necessary. If `--task` is omitted, the Server infers a target only when all running tasks belong to one conversation and rejects the request when multiple running conversations make ownership ambiguous. Startup cards are service-wide notices: every known private chat receives one on every startup, groups receive one when active in the previous minute or enrolled for the current safe restart, and topic routes receive the card in their parent group rather than inside the topic.
+
 On Windows, initial start, safe or immediate replacement, and every crash-driven Worker launch reload the latest Machine and User environment variables. After changing `PATH` or installing a CLI shim, finish the current work and use the normal restart path. Agent Bot keeps `AGENT_BOT_*` and `FEISHU_*` process-local so Profile selection and bot credentials do not leak between isolated instances.
 
 In Feishu, `/restart` schedules the same safe restart. Use `/restart --force` only when the user explicitly accepts interruption; the command accepts no other arguments.
@@ -128,6 +145,7 @@ List tasks before resolving a numeric reference because task numbers follow the
 
 ```powershell
 agentbot task list
+agentbot task current [--json]
 agentbot task chat <number-or-task-id> [--json]
 agentbot task status <number-or-task-id>
 agentbot task stop <number-or-task-id>
@@ -139,59 +157,78 @@ agentbot task forkgroup <number-or-task-id> [title] [--json]
 
 Task IDs may be supplied in full or as an unambiguous prefix. Use `task stop` to ask the running worker to send the App Server Interrupt signal; leave child-process lifecycle management to the selected Agent.
 
+Read all task identity fields from `task list`: every entry shows its Agent and `AgentBot task ID`; App Server tasks also show `App Server thread ID`, while ACP tasks show `ACP session ID`. The status, title, conversation context, and update time remain visible. The CLI reads `CODEX_THREAD_ID` for Codex and `TRAECLI_THREAD_ID` for TraeX; when the available native Thread IDs identify one task, it marks that entry as `Current`. Use `task current` to print that task's details directly. Use any displayed full ID or an unambiguous prefix as a task reference. With `--json`, read the local and native values from `localSessionId`, `remoteSessionId`, and `acpSessionId`.
+
 Use `task chat <number-or-task-id>` to read the Feishu chat ID associated with a task from local routing state. Plain output is only the chat ID for scripting. Add `--json` to include the stable task ID, complete context key, and the thread ID for a topic-bound task. This read-only command does not require the Agent Bot server to be running.
 
 Use `task prompt` to send input to a specific task without changing any chat's current task. The bot first posts the Prompt text to the task's existing Feishu chat, thread, or private-chat route, then submits it to the task. If posting fails, the task is not started or steered. The thinking card and final response continue to the same route; the command line only reports whether the Prompt was accepted.
 
-### Create a task group from the CLI
+### Create or fork a group from the CLI
+
+Choose by whether the new task needs the source conversation:
+
+- Use **New Group** for a fresh task in a separate private Lark group. Inherit the project and execution settings, but do not carry over prior turns. Use it for a separate assignment in the same codebase or for a different project or Agent.
+- Use **Fork Group** to continue or parallelize work with the source task's conversation through a completed turn. Preserve that context in a separate private Lark group.
+
+Both operations create and bind the destination task immediately. Neither interrupts the source task nor changes the source chat's current task.
+
+When creating or forking from the task that is currently running this Skill, run `agentbot task current --json` first and pass its `localSessionId` as `<number-or-task-id>`. The command resolves Codex through `CODEX_THREAD_ID` and TraeX through `TRAECLI_THREAD_ID`, while preferring the only running match when another Agent's variable was inherited from a parent process. If the command cannot identify one task, ask for an explicit AgentBot task ID instead of guessing from list order, title, or project directory.
 
-Use `task newgroup` to create a Lark group and bind a new task from outside Feishu. List tasks first and pass the intended source task explicitly; `<number-or-task-id>` defines the source context, so never substitute the shell's current working directory for the task's project directory.
+List tasks first, identify the intended source explicitly, then run one of these commands:
 
 ```powershell
-# Inherit the source task's Agent, project, and execution settings.
+agentbot task list
+
+# Fresh task: inherit the source Agent, project, and execution settings.
 agentbot task newgroup <number-or-task-id> "Review"
 
-# Override the project directory. Prefer an absolute path or a ~-based path.
+# Fresh task: override the inherited project directory.
 agentbot task newgroup <number-or-task-id> "Review" --dir ~/dev/project
 
-# Create a fresh Projectless App Server task instead of inheriting a project.
+# Fresh task: use a Projectless App Server workspace.
 agentbot task newgroup <number-or-task-id> "Question" --nodir
 
-# Use another configured Agent with the inherited project shape.
+# Fresh task: use another configured Agent and that Agent's defaults.
 agentbot task newgroup <number-or-task-id> "Review" --agent traex
+
+# Context-preserving branch from the source task.
+agentbot task forkgroup <number-or-task-id> "Parallel review"
 ```
 
-Apply these rules:
+Apply these New Group rules:
 
-- With neither `--dir` nor `--nodir`, inherit the source task's project directory. If the source is Projectless, create a fresh Projectless workspace rather than reusing its generated directory.
-- `--dir <cwd>` overrides the inherited project and resolves `~`, `~/...`, and `~\...` from the user's home directory.
-- `--nodir` forces a Projectless task and is valid only for an App Server Agent. Reject combining it with `--dir`.
-- With no `--agent`, inherit the source task's Agent, Provider, model, reasoning effort, and permission mode. When `--agent <standard-name>` selects a different Agent, retain the chosen or inherited project shape but use that Agent runtime's own execution defaults.
-- The Server must be running. The Profile must contain `FEISHU_USER_OPEN_ID`; the Server invites that saved authorizing user because the CLI has no Lark operator identity.
-- Creating the group must not interrupt the source task or switch the source chat's current task. Add `--json` when the caller needs `group.chatId`, `group.contextKey`, or the created task IDs.
+- Treat `<number-or-task-id>` as the source context; never substitute the shell's current working directory for its project directory.
+- With neither `--dir` nor `--nodir`, inherit the source project. If it is Projectless, create a fresh Projectless workspace rather than reusing its generated directory.
+- Resolve `~`, `~/...`, and `~\...` in `--dir <cwd>` from the user's home directory. Reject combining `--dir` with `--nodir`.
+- Allow `--nodir` only for an App Server Agent.
+- With no `--agent`, inherit the source Agent, Provider, model, reasoning effort, and permission mode. With `--agent <standard-name>`, preserve the selected project shape but use the selected Agent's runtime defaults. `--agent` is a CLI-only New Group option.
 
-Use `task forkgroup` to Fork the selected task's latest available completed turn into a new group. It does not interrupt a newer active source turn and does not switch the source chat. Both group commands accept an optional title and `--json`; use the structured result to read the new `group.chatId`, `group.contextKey`, and task IDs.
+Apply these Fork Group rules:
 
-Use `/queue <prompt>` in Feishu to persist a separate follow-up Prompt instead of steering the active turn. Queued Prompts run in FIFO order after the current turn completes and survive Agent Bot restarts. `/nosteer <prompt>` is an equivalent compatibility spelling.
+- Fork the latest available completed turn and preserve its conversation context. Never include or interrupt a newer active turn. Reject the request when no completed turn is available.
+- Keep the source Agent, project, Provider, model, reasoning effort, and permission mode. Fork Group does not accept Agent or project overrides; use New Group when those must change.
+- Use the optional title as the destination task title and group suffix.
 
-For a long-running objective in the active Feishu task, use `/goal <objective>`. Use `/goal` to inspect it, `/goal pause` or `/goal resume` to control automatic continuation, `/goal edit <objective>` to revise it, and `/goal clear` to remove it. Stopping a Goal turn through Agent Bot also pauses the Goal before sending Interrupt so it does not immediately continue.
+Require a running Server for either CLI command. Require `FEISHU_USER_OPEN_ID` so the Server can invite the saved authorizing user; the CLI has no Lark operator identity of its own. Add `--json` when the caller needs `group.chatId`, `group.contextKey`, or the created task IDs.
 
-Use `/agent` in Feishu to open the unified execution-settings card on its Agent tab and `/agent <name>` to directly select the default agent. The Agent tab is present only when multiple agents are configured and remains usable before the chat has a current task. When only one Agent is configured, `/agent` reports that current Agent directly instead of sending a card. Agent selection affects future tasks and does not replace the Agent of an existing task; use `/new` after selecting when a new task is needed.
+Name a New Group without an explicit title as `[agent] [project directory] 新任务 (mm-dd)`, or `[agent] 新任务 (mm-dd)` when Projectless. Name an untitled Fork Group with the source task's persistent `source title（分支 N）` sequence, without a date suffix. Cap the displayed Lark group name at 60 characters by truncating only the group title portion; preserve the complete Agent Bot task title. Do not automatically send a Sessions or Status card to the destination group. Send a welcome message that reports Provider, model, reasoning effort, and permission mode.
 
-Use `/newgroup [title] [--dir <cwd> | --nodir]` in Feishu to create a private group named `[agent] [project directory] <title>`, invite the command sender, and immediately create and bind a new task in that group. `/new` and `/newgroup` share the same project options: an explicit `--dir` overrides the inherited project directory, while `--nodir` forces a Projectless App Server task; reject using both together. Resolve `~`, `~/...`, and `~\...` from the current user's home directory for both commands. Projectless groups omit the project segment and use `[agent] <title>`. The new task inherits the source chat's current task project directory when neither option is present, plus its model, reasoning effort, and permission mode without interrupting or switching the source task. When the source chat has no current task, use the selected agent and its runtime defaults. An explicit title becomes both the group suffix and the task title. When the title is omitted, use task title `新任务` and group name `[agent] [project directory] 新任务 (mm-dd)`, or `[agent] 新任务 (mm-dd)` for Projectless; an explicit title never gets a date suffix. Every new group gets a deterministic scheme-C Identicon avatar: Latin project names display their first word, Chinese names display up to their first four characters, and the normalized full project path hashes into the palette and symmetric node pattern. Projectless groups use the title as the stable seed. Replace the user's home-directory prefix with `~`. The bracketed project-directory value is limited to 15 characters. Longer paths keep the final two directories when they fit, otherwise keep the final directory, truncating the tail only when the final directory itself is overlong. Use `\` on Windows and `/` on macOS/Linux. Do not automatically send a Sessions or Status card to the new group. A later `/new --dir <cwd>` or `/new --nodir` in the group may explicitly replace the inherited project shape.
+Give every created group a deterministic scheme-C Identicon avatar. Display the first word for Latin project names or up to four characters for Chinese names, and hash the normalized full project path into the palette and symmetric node pattern. Use the title as the stable seed for Projectless groups. Replace the user's home prefix with `~` in the group-name project segment. Limit that segment to 15 characters, preferring the final two directories, then the final directory, and only then tail truncation. Use `\` on Windows and `/` on macOS/Linux.
 
-Provider is part of the same inherited execution-settings group as model, reasoning effort, and permission mode. Preserve all four across `/new`, `/newgroup`, `/fork`, `/forkgroup`, and the matching `/sessions` actions. New tasks with no inherited Provider must leave it unset so the selected App Server Agent uses its own default configuration. New-group welcome messages report all four settings.
+Use `/queue <prompt>` in Feishu to persist a separate follow-up Prompt instead of steering the active turn. Queued Prompts run in FIFO order after the current turn completes and survive Agent Bot restarts. `/nosteer <prompt>` is an equivalent compatibility spelling.
 
-Group names created by `/newgroup` and `/forkgroup` are capped at 60 displayed characters. When the generated name would exceed that limit, truncate only the title portion in the Feishu group name; preserve the underlying Agent Bot task title.
+For a long-running objective in the active Feishu task, use `/goal <objective>`. Use `/goal` to inspect it, `/goal pause` or `/goal resume` to control automatic continuation, `/goal edit <objective>` to revise it, and `/goal clear` to remove it. Stopping a Goal turn through Agent Bot also pauses the Goal before sending Interrupt so it does not immediately continue.
 
-Use `/forkgroup [title]` in Feishu to fork the current position into a newly created private group. In a Feishu thread, use the thread's original anchor turn when the thread has no bound task or its bound task has not completed a turn of its own. Once the bound thread task has completed a turn, use its latest locally persisted completed turn; exclude any newer active turn without interrupting it. Resolve this source before generic thread initialization so an unbound thread does not create an intermediate task. Outside a thread, fork the current App Server task's latest available completed turn. Agent Bot invites the command sender and binds the fork as the new group's current task, but does not automatically send a Sessions or Status card there. The new-group welcome message reports the forked task's model, reasoning effort, and permission type. An explicit title is used directly. Without an explicit title, both the forked task and group name use the same persistent `source title（分支 N）` sequence as `/fork`. `/forkgroup` does not add a date suffix.
+Use `/agent` in Feishu to open the unified execution-settings card on its Agent tab and `/agent <name>` to directly select the default agent. The Agent tab is present only when multiple agents are configured and remains usable before the chat has a current task. When only one Agent is configured, `/agent` reports that current Agent directly instead of sending a card. Agent selection affects future tasks and does not replace the Agent of an existing task; use `/new` after selecting when a new task is needed.
 
 Use `/new [title] --nodir` to force a new App Server Projectless task even when the current task belongs to a project. `--nodir` and `--dir <cwd>` are mutually exclusive; omitting both preserves the normal project-shape inheritance behavior.
 
-Every task in the Feishu `/sessions` card has `New`, `NewGroup`, `Fork`, and `ForkGroup` actions. `New` inherits the source task's project directory, model, reasoning effort, and permission mode, creates a new task, and switches the current chat to it without stopping or forking the source task. `NewGroup` applies the same inheritance in a newly created private group. `Fork` switches the current chat to a branch, while `ForkGroup` binds the branch to a newly created private group; both fork actions use the selected task's latest available completed turn without interrupting an active turn.
+The Feishu `/sessions` card shows five tasks per page and updates the same card through `Previous` and `Next`; it never expands earlier pages into one long card. Every task has `New`, `NewGroup`, `Fork`, and `ForkGroup` actions. `New` inherits the source task's project directory, model, reasoning effort, and permission mode, creates a new task, and switches the current chat to it without stopping or forking the source task. `NewGroup` applies the same inheritance in a newly created private group. `Fork` switches the current chat to a branch, while `ForkGroup` binds the branch to a newly created private group; both fork actions use the selected task's latest available completed turn without interrupting an active turn.
 
 Use `/fork [number-or-task-id]` in Feishu to branch from the current or specified App Server task and switch to the new branch. If the source task is running, Agent Bot forks from its latest completed turn and leaves the active turn running; it rejects only when the task has no completed turn yet. Every fork request sends `excludeTurns: true` to the App Server so the response omits populated turns without removing turns from the forked history. Older App Servers that explicitly reject this experimental field are retried once without it; ambiguous failures such as timeouts or disconnects are not retried.
 
+Successfully completed Feishu thinking cards include a bottom `Reset` action followed by its compact warning. `/turns` opens the current task's completed-turn history with the Reset-effect warning at the top and 10 turns per page. It renders each entry as an indented numbered node in a commit graph whose lanes follow persisted parent turns, including Reset branches and merges across page boundaries. A successful Reset refreshes that card in place, moves the current marker to the selected turn, and sends a confirmation containing the target Prompt summary, completion time, and Turn ID. Reset forks the selected turn's original App Server thread through that turn and replaces the current task's remote thread binding in place, preserving the local task ID, title, Agent, project directory, execution settings, and chat route. Completed snapshots after the selected point remain visible together with later turns from the new branch. Reset is available only when the card still belongs to the current task and the task is idle. It restores conversation context only and never reverts local files.
+
 Status cards include a `Refresh` action that reads the latest task state and updates the same card in place without switching tasks or sending another card.
 
 Use `/agent`, `/provider`, `/model`, `/thinking`, or `/permissions` in Feishu to open the same interactive Card 2.0 execution-settings card with the corresponding tab active. The card exposes Provider, Model, Thinking, and Permission tabs whenever a current task exists, plus an Agent tab when multiple agents are configured. Each non-current option has an English `Switch` action. Selecting an option refreshes the same card in place. Agent changes affect future tasks; the other settings apply from the next request. Model changes automatically choose a compatible reasoning effort when necessary.
@@ -213,7 +250,7 @@ Use `--context <key>` or `--status <status>` to narrow `task list`. Use `--profi
 After changing Agent Bot code, run the relevant tests, typecheck, and build. If a running service must pick up the result, schedule:
 
 ```powershell
-agentbot server restart --reason "brief description of the completed change"
+agentbot server restart --task <current-task-id> --reason "brief description of the completed change"
 ```
 
 Do not replace the worker immediately while a task is active. A later incoming task must not cancel the pending safe restart; allow the scheduler to wait until the service becomes safely idle again.

package/src/acp/AcpProcessManager.ts

@@ -3,7 +3,10 @@ import readline from "node:readline";
 import type { Logger } from "pino";
 import type { AgentConfig } from "../config/schema.js";
 import { AcpJsonRpcConnection } from "./AcpJsonRpcConnection.js";
-import { agentBotEnvironment } from "../runtime/agentEnvironment.js";
+import {
+  agentBotEnvironment,
+  type AgentEnvironmentContext,
+} from "../runtime/agentEnvironment.js";
 import { spawnStdioCommand } from "../utils/spawnCommand.js";
 
 export interface ManagedAcpProcess {
@@ -16,14 +19,24 @@ export interface ManagedAcpProcess {
 export class AcpProcessManager {
   private readonly processes = new Map<string, ManagedAcpProcess>();
 
-  constructor(private readonly logger: Logger) {}
+  constructor(
+    private readonly logger: Logger,
+    private readonly environmentContext: () => AgentEnvironmentContext = () => ({}),
+  ) {}
 
   start(processKey: string, agentName: string, agent: AgentConfig): ManagedAcpProcess {
     if (this.processes.has(processKey)) {
       throw new Error(`ACP process already exists: ${processKey}`);
     }
 
-    const child = spawnStdioCommand(agent.command, agent.args, agentBotEnvironment(process.env, agent.env));
+    const child = spawnStdioCommand(
+      agent.command,
+      agent.args,
+      agentBotEnvironment(process.env, agent.env, {
+        ...this.environmentContext(),
+        agentName,
+      }),
+    );
 
     const childLogger = this.logger.child({ processKey, agentName });
     const connection = new AcpJsonRpcConnection(child, childLogger);

package/src/acp/AcpSessionManager.ts

@@ -40,6 +40,7 @@ export class AcpSessionManager {
   private readonly sessions = new Map<string, RuntimeSession>();
   private readonly sessionsByAcpId = new Map<string, RuntimeSession>();
   private processStart?: Promise<ManagedAcpProcess>;
+  private processVersion?: string;
 
   constructor(
     private readonly agentName: string,
@@ -52,6 +53,15 @@ export class AcpSessionManager {
     return this.sessions.get(localSessionId);
   }
 
+  getProcessInfo(): { pid?: number; version?: string } {
+    const pid = this.processManager.get(this.agentName)?.child.pid;
+    if (!pid) return {};
+    return {
+      pid,
+      ...(this.processVersion ? { version: this.processVersion } : {}),
+    };
+  }
+
   async create(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
     if (input.agentName !== this.agentName) throw new Error(`Unexpected agent: ${input.agentName}`);
 
@@ -133,6 +143,7 @@ export class AcpSessionManager {
     this.sessions.clear();
     this.sessionsByAcpId.clear();
     this.processStart = undefined;
+    this.processVersion = undefined;
     this.processManager.stopAll();
   }
 
@@ -181,6 +192,7 @@ export class AcpSessionManager {
   }
 
   private async startProcess(): Promise<ManagedAcpProcess> {
+    this.processVersion = undefined;
     const managed = this.processManager.start(this.agentName, this.agentName, this.agent);
     try {
       const connection = managed.connection;
@@ -210,6 +222,8 @@ export class AcpSessionManager {
           version: "0.1.0",
         },
       });
+      const version = initializeResult.agentInfo?.version?.trim();
+      if (version) this.processVersion = version;
       if (initializeResult.authMethods?.length) {
         const method = initializeResult.authMethods[0];
         this.logger.info({ methodId: method.id }, "Authenticating ACP agent with first advertised method.");

package/src/cli/ServerStarter.ts

@@ -11,7 +11,11 @@ import {
 import { refreshedSystemEnvironment } from "../supervision/systemEnvironment.js";
 import { controlEndpoint } from "./controlProtocol.js";
 import { cliText } from "./i18n.js";
-import { isServerReachable, isServerRunning } from "./LocalControlClient.js";
+import {
+  isServerReachable,
+  isServerRunning,
+  sendControlRequest,
+} from "./LocalControlClient.js";
 
 export interface ServerStartResult {
   status: "started" | "already-running";
@@ -19,6 +23,7 @@ export interface ServerStartResult {
 
 export type InitializationServerResult =
   | ServerStartResult
+  | { status: "restart-scheduled" }
   | { status: "skipped"; reason: "feishu-skipped" };
 
 export interface ServerStarterDependencies {
@@ -33,6 +38,7 @@ const SERVER_START_TIMEOUT_MS = 45_000;
 interface InitializationServerDependencies {
   loadConfig(configPath?: string): AppConfig;
   startServer(config: AppConfig): Promise<ServerStartResult>;
+  restartServer(config: AppConfig): Promise<void>;
 }
 
 export async function startInitializedServer(
@@ -42,7 +48,11 @@ export async function startInitializedServer(
   if (options.skipFeishu) {
     return { status: "skipped", reason: "feishu-skipped" };
   }
-  return dependencies.startServer(dependencies.loadConfig(options.configPath));
+  const config = dependencies.loadConfig(options.configPath);
+  const result = await dependencies.startServer(config);
+  if (result.status !== "already-running") return result;
+  await dependencies.restartServer(config);
+  return { status: "restart-scheduled" };
 }
 
 export async function startServer(
@@ -116,6 +126,19 @@ const defaultDependencies: ServerStarterDependencies = {
 const defaultInitializationDependencies: InitializationServerDependencies = {
   loadConfig,
   startServer: (config) => startServer(config),
+  restartServer: async (config) => {
+    const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+      action: "server_restart",
+      mode: "safe",
+      reason: "Agent Bot 初始化完成，需要加载当前版本",
+    });
+    if (!response.ok) {
+      throw new Error(response.message?.trim() || cliText(
+        "Could not schedule the Agent Bot restart after initialization.",
+        "初始化完成后无法安排 Agent Bot 重启。",
+      ));
+    }
+  },
 };
 
 async function waitForServer(endpoint: string, timeoutMs: number): Promise<boolean> {

package/src/cli/controlProtocol.ts

@@ -6,7 +6,12 @@ import type { SessionRecord } from "../state/StateStore.js";
 
 export type ControlRequest =
   | { action: "health" }
-  | { action: "server_restart"; mode: "safe" | "immediate"; reason: string }
+  | {
+      action: "server_restart";
+      mode: "safe" | "immediate";
+      reason: string;
+      notificationSessionId?: string;
+    }
   | { action: "server_stop" }
   | { action: "task_status"; localSessionId: string }
   | { action: "task_stop"; localSessionId: string }

package/src/cli/help.ts

@@ -13,10 +13,11 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   init --reset                      重置并重新配置显式指定的 Profile
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
-  server status                     显示服务、飞书 App ID 和安全重启状态
-  server restart                    安排安全重启
+  server status                     显示服务、飞书 App ID、Agent 进程和安全重启状态
+  server restart [--task <任务>]    安排安全重启并将状态发回指定任务会话
   server stop                       停止 Agent Bot
   task list                         列出任务
+  task current [--json]             显示当前调用任务的详情
   task status <任务>                显示任务状态
   task chat <任务>                  显示任务绑定的飞书会话
   task prompt <任务> <提示词>       向任务发送提示词
@@ -39,6 +40,11 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   --skip-feishu                     仅初始化 Console 环境
   --reconfigure-feishu              仅替换现有飞书凭据
 
+重启选项：
+  --task <任务>                     将安全重启状态发回任务所在会话
+  --reason <原因>                   设置重启原因
+  --immediate                       立即重启，可能中断任务
+
 示例：
   agentbot init
   agentbot --profile ~/.agent-bot init --reset
@@ -61,10 +67,11 @@ Common commands:
   init --reset                      Reset and reconfigure an explicit profile
   console                           Open the local console
   server start                      Start Agent Bot in the background
-  server status                     Show the server, Lark App ID, and safe-restart status
-  server restart                    Schedule a safe restart
+  server status                     Show the server, Lark App ID, Agent processes, and safe-restart status
+  server restart [--task <task>]    Schedule a safe restart and return status to the task's conversation
   server stop                       Stop Agent Bot
   task list                         List tasks
+  task current [--json]             Show details for the task invoking the CLI
   task status <task>                Show task status
   task chat <task>                  Show the task's Lark chat binding
   task prompt <task> <prompt>       Send a Prompt to a task
@@ -87,6 +94,11 @@ Init options:
   --skip-feishu                     Initialize for Console only
   --reconfigure-feishu              Replace only the existing Lark credentials
 
+Restart options:
+  --task <task>                     Return safe-restart status to the task's conversation
+  --reason <reason>                 Set the restart reason
+  --immediate                       Restart immediately and possibly interrupt tasks
+
 Examples:
   agentbot init
   agentbot --profile ~/.agent-bot init --reset

package/src/cli/serverStatus.ts

@@ -29,16 +29,44 @@ export function formatServerStatus(data: unknown, language: CliLanguage = cliLan
         language,
       )
     : cliText("not scheduled", "未计划", language);
+  const agents = formatAgentProcesses(value.agents, language);
   return [
     `${cliText("Agent Bot server: ", "Agent Bot 服务：", language)}${state}`,
     `${cliText("Lark App ID: ", "飞书 App ID：", language)}${value.feishuAppId ?? cliText("not configured", "未配置", language)}`,
     `${cliText("PID: ", "PID：", language)}${value.pid ?? "-"}`,
     `${cliText("Started at: ", "启动时间：", language)}${value.startedAt ?? "-"}`,
     `${cliText("Supervisor: ", "Supervisor：", language)}${value.supervised ? cliText("enabled", "已启用", language) : cliText("disabled", "未启用", language)}`,
+    ...agents,
     `${cliText("Running tasks: ", "运行中任务：", language)}${activity.runningSessions ?? 0}`,
     `${cliText("Pending final deliveries: ", "待发送最终结果：", language)}${activity.pendingFinalDeliveries ?? 0}`,
     `${cliText("Safe restart: ", "安全重启：", language)}${safeRestart}`,
     "",
   ].join("\n");
 }
+
+function formatAgentProcesses(value: unknown, language: CliLanguage): string[] {
+  const agents = Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object")
+    : [];
+  if (agents.length === 0) {
+    return [`${cliText("Agents: ", "Agent 进程：", language)}-`];
+  }
+  return [
+    cliText("Agents:", "Agent 进程：", language),
+    ...agents.map((agent) => {
+      const name = typeof agent.name === "string" && agent.name.trim() ? agent.name.trim() : "-";
+      const title = typeof agent.title === "string" && agent.title.trim() ? agent.title.trim() : undefined;
+      const label = title && title !== name ? `${name} (${title})` : name;
+      const pid = typeof agent.pid === "number" && Number.isInteger(agent.pid) && agent.pid > 0
+        ? String(agent.pid)
+        : "-";
+      const version = typeof agent.version === "string" && agent.version.trim()
+        ? agent.version.trim()
+        : "-";
+      return language === "zh"
+        ? `  ${label}：PID ${pid}，版本 ${version}`
+        : `  ${label}: PID ${pid}, version ${version}`;
+    }),
+  ];
+}
 import { cliLanguage, cliText, type CliLanguage } from "./i18n.js";