lark-remote 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.11] - 2026-08-24
+
+### 新增
+
+- kimi ACP 支持 Bash 命令自主执行：`terminal/*` reverse RPC 将 Bash 工具下放到本地子进程（一次性 `bash -c <script>`），yolo/auto 模式自主跑命令，manual 模式仍走审批；run 卡片显示带真实命令与本地输出的 Bash 面板，并过滤 kimi 自产的双份 Bash 通知
+
+### 变更
+
+- kimi ACP 能力声明：`fs` 保持关闭（走本地磁盘兜底，避免未实现的 `fs/*` RPC 报 `METHOD_NOT_FOUND`），`terminal` 打开
+- 文档清理：移除设计文档中对内部文档名（`lessons-redlines`）与本地仓库路径（`/Users/.../lark-remote`）的引用
+
+## [0.1.10] - 2026-08-22
+
+### 新增
+
+- `/order` 卡片指令文本编辑：卡片「编辑」按钮弹出输入框原地修改（保留别名/使用统计/创建时间），CLI `/order edit <orderId|序号> <新文本>` 备选入口；长度上限 200 字符、空白提交报错、文本未变化短路写盘
+
+### 修复
+
+- cardAction 直返白名单补齐：`order.textInput` 与 `approval.planFeedback` 不再被 fire-and-forget 的 `enqueueImmediate` 吞掉返回值（编辑卡停留编辑界面 / 计划审批意见 toast 消失）
+- DSH `selectModel` 写放大：`session.selectModel`（会写服务端全局默认）改为每 session 首次 run 对齐一次，不再每次 run 重复写；启动期 `/stop` 会取消刚创建的 session 并产出 `interrupted` 终态而非静默返回
+- order 末页删空守卫：删除末页唯一指令后 `offset` 回退到非空页（不再出现空白卡）
+- 计划审批意见门控：仅 `ExitPlanMode` 工具审批接受修改意见，其他审批类型拒绝
+- 计划文件跨 run 重置：`doStartProcess` 清空会话内追踪的计划文件，避免旧计划被 `resolvePlanContent` 误读
+- finalizeRun fallback 卡按 `compactSupported` 门控 Compact 按钮（无 `runCompact` 能力的 agent 不再渲染死按钮）
+
+### 变更
+
+- ESLint 告警清零（0 errors 0 warnings）
+- 注释与文档同步 DSH 接入（"5 个 agent"→"6 个 agent"）
+
 ## [0.1.9] - 2026-08-20
 
 ### 新增

package/README.en.md

@@ -6,7 +6,7 @@ English | [简体中文](README.md)
 [![npm](https://img.shields.io/npm/v/lark-remote.svg)](https://www.npmjs.com/package/lark-remote)
 [![CI](https://github.com/bungabungawoda/lark-remote/actions/workflows/ci.yml/badge.svg)](https://github.com/bungabungawoda/lark-remote/actions/workflows/ci.yml)
 
-A bridge between Feishu (Lark) private chat and local coding agents. Talk to Claude Code (or Codex / opencode / pi / Kimi) from Feishu — the agent reads/writes files and runs commands in a local directory you pick, with execution streamed live into a single CardKit 2.0 card.
+A bridge between Feishu (Lark) private chat and local coding agents. Talk to Claude Code (or Codex / opencode / pi / Kimi / DSH) from Feishu — the agent reads/writes files and runs commands in a local directory you pick, with execution streamed live into a single CardKit 2.0 card.
 
 Designed for a single-user, peer-to-peer private chat. The agent's system prompt is never modified.
 
@@ -32,7 +32,7 @@ In Codex approval mode, an approval card arrives before any command runs — app
 - OS: macOS / Linux. **Windows is not supported yet** (relies on POSIX behaviors such as Unix signals, bash, and file locks)
 - Node.js 20+ ([Bun](https://bun.sh/) for development)
 - A Feishu custom app (either way): scan-to-create (a QR code pops up in the terminal on first launch; scan it with the Feishu app to create the app and write credentials automatically); or create one manually in the Open Platform — enable bot capability, subscribe to `im.message.receive_v1` and `card.action.trigger` via **long connection** (WebSocket, no public address needed), with at least the `im:message` scope.
-- Claude Code CLI installed locally and logged in once in a terminal (`claude` → browser OAuth). Same idea for other agents (codex / opencode / pi / kimi): install the corresponding CLI first.
+- Claude Code CLI installed locally and logged in once in a terminal (`claude` → browser OAuth). Same idea for other agents (codex / opencode / pi / kimi): install the corresponding CLI first. DSH connects to a local DSH Web Host via HTTP+WebSocket (no local subprocess), default address `http://127.0.0.1:3080`.
 
 ## Installation
 
@@ -64,7 +64,7 @@ feishu:
   appId: cli_xxx
   appSecret: xxx
 
-# default agent: claude | codex | opencode | pi | kimi (default: claude)
+# default agent: claude | codex | opencode | pi | kimi | dsh (default: claude)
 defaultAgent: claude
 
 claude:
@@ -124,7 +124,7 @@ Your original message also gets an emoji reaction: `Typing` while the run is in
 | `/reconnect` | - | Reconnect to Feishu |
 | `/restart` | - | In-place bridge self-restart (new process takes over with the same config) |
 | `/config get\|set` | `/c` | View/change runtime config (agent-aware card) |
-| `/order save\|list` | `/o` | Save or list frequently used prompts |
+| `/order save\|list\|edit` | `/o` | Save, list, or edit frequently used prompts |
 | `!<cmd>` | - | Run a bash command with streaming card output (bypasses the serial queue) |
 | `/exit` | `/e` | Exit the bridge |
 

package/README.md

@@ -6,7 +6,7 @@
 [![npm](https://img.shields.io/npm/v/lark-remote.svg)](https://www.npmjs.com/package/lark-remote)
 [![CI](https://github.com/bungabungawoda/lark-remote/actions/workflows/ci.yml/badge.svg)](https://github.com/bungabungawoda/lark-remote/actions/workflows/ci.yml)
 
-飞书私聊 ↔ 本地 Coding Agent 桥接。在飞书里和 Claude Code（或 Codex / opencode / pi / Kimi）对话，agent 在你指定的本地目录里读写文件、跑命令，执行过程以 CardKit 2.0 卡片**单卡实时流式**呈现。
+飞书私聊 ↔ 本地 Coding Agent 桥接。在飞书里和 Claude Code（或 Codex / opencode / pi / Kimi / DSH）对话，agent 在你指定的本地目录里读写文件、跑命令，执行过程以 CardKit 2.0 卡片**单卡实时流式**呈现。
 
 单用户、p2p 私聊场景设计，不修改 agent 的 system prompt。
 
@@ -32,7 +32,7 @@ Codex 审批模式下，执行命令前会收到审批卡片，可直接在飞
 - 操作系统：macOS / Linux。**暂不支持 Windows**（依赖 Unix 信号、bash、文件锁等 POSIX 行为）
 - Node.js 20+（开发时用 [Bun](https://bun.sh/)）
 - 飞书自建应用（二选一）：扫码创建（首次启动终端弹二维码，飞书 App 扫码即自动创建并写入凭据）；或手动在开放平台建应用——开启机器人能力，订阅 `im.message.receive_v1` 和 `card.action.trigger`，订阅方式选「长连接」（WebSocket，无需公网地址），权限至少 `im:message`。
-- Claude Code CLI：本地安装并在终端完成一次登录（`claude` → 浏览器 OAuth）。使用其他 agent（codex / opencode / pi / kimi）同理，先装好对应 CLI。
+- Claude Code CLI：本地安装并在终端完成一次登录（`claude` → 浏览器 OAuth）。使用其他 agent（codex / opencode / pi / kimi）同理，先装好对应 CLI；DSH 需本地 DSH Web Host 在跑（默认 `http://127.0.0.1:3080`），lark-remote 通过 HTTP+WebSocket 直连、不 spawn 本地子进程。
 
 ## 安装
 
@@ -64,7 +64,7 @@ feishu:
   appId: cli_xxx
   appSecret: xxx
 
-# 默认 agent：claude | codex | opencode | pi | kimi，默认 claude
+# 默认 agent：claude | codex | opencode | pi | kimi | dsh，默认 claude
 defaultAgent: claude
 
 claude:
@@ -124,7 +124,7 @@ bridge 启动后不在终端输出，运行日志写入 `~/.lark-remote/logs/YYY
 | `/reconnect` | - | 重连飞书 |
 | `/restart` | - | 原地自重启 bridge（新进程同 config 接管） |
 | `/config get\|set` | `/c` | 查改运行时配置（agent-aware 卡片） |
-| `/order save\|list\|alias` | `/o` | 收藏常用指令；`/order alias` 注册快捷别名（输入 `$name` 展开） |
+| `/order save\|list\|edit\|alias` | `/o` | 收藏常用指令；`/order edit` 修改指令文本（保留别名/使用统计）；`/order alias` 注册快捷别名（输入 `$name` 展开） |
 | `!<cmd>` | - | 执行 bash 命令并流式输出到卡片（绕过串行队列） |
 | `/exit` | `/e` | 退出 bridge |
 

package/dist/bridge/approval-coordinator.d.ts

@@ -121,6 +121,9 @@ export declare class ApprovalCoordinator {
      * 计划审批修改意见（ExitPlanMode）：输入框提交 → coordinator 记录并回流
      * 卡片回显，随后「拒绝并附意见」/「批准并采纳修改」按钮复用该文本。
      * 同一请求可多次修改（新 nonce 来自新渲染）。
+     * 仅 kind === 'tool' 且 toolName === 'ExitPlanMode' 的计划审批接受反馈；
+     * 其余审批类型（command/file/permissions/question）没有反馈类决策，
+     * 存意见无意义（卡片侧也不渲染该输入框，此处兜底防异常卡片 payload）。
      */
     planFeedback(action: {
         text: string;

package/dist/bridge/approval-coordinator.js

@@ -274,6 +274,9 @@ export class ApprovalCoordinator {
      * 计划审批修改意见（ExitPlanMode）：输入框提交 → coordinator 记录并回流
      * 卡片回显，随后「拒绝并附意见」/「批准并采纳修改」按钮复用该文本。
      * 同一请求可多次修改（新 nonce 来自新渲染）。
+     * 仅 kind === 'tool' 且 toolName === 'ExitPlanMode' 的计划审批接受反馈；
+     * 其余审批类型（command/file/permissions/question）没有反馈类决策，
+     * 存意见无意义（卡片侧也不渲染该输入框，此处兜底防异常卡片 payload）。
      */
     async planFeedback(action, ctx) {
         const tracked = this.approvals.get(ctx.requestId);
@@ -283,6 +286,9 @@ export class ApprovalCoordinator {
         if (tracked.state !== 'pending') {
             throw new Error(`Approval request ${ctx.requestId} is no longer pending`);
         }
+        if (tracked.kind !== 'tool' || tracked.view.toolName !== 'ExitPlanMode') {
+            throw new Error('仅计划审批（ExitPlanMode）支持修改意见');
+        }
         const text = action.text.trim();
         if (!text) {
             throw new Error('请输入修改意见');

package/dist/bridge/index.js

@@ -1287,6 +1287,10 @@ export class Bridge {
                         showToolUse: this.config.output.showToolUse,
                         showToolResult: this.config.output.showToolResult,
                         agentKind: activeRun.agentKind,
+                        // 与 createRunSession 的 renderOptions 一致：fallback 卡也要按
+                        // runner 能力门控 Compact 按钮（缺省 undefined = 显示按钮，
+                        // DSH 等无 runCompact 的 agent 会渲染出点了报错的死按钮）。
+                        compactSupported: this.hasRunCompact(cwd, activeRun.agentKind),
                     }),
                 }, ctx);
                 runCardSent = sent;

package/dist/index.js

@@ -532,17 +532,21 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         // 直返列表外，过期/重复 nonce/非法选项等错误 toast 被静默吞掉）。
         // 审批响应尤其不能落串行队列：run 任务占用队列头直到 turn 结束，审批响应
         // 排在后面会形成死锁（run 不结束不执行、run 结束 coordinator 已删响应空转）。
-        // order.aliasInput / order.aliasRemove 也返回 toast，需直返避免被吞。
+        // order.aliasInput / order.aliasRemove / order.textInput 也返回 toast+card，
+        // 需直返避免被吞（order.textInput 曾漏在列表外，编辑卡停留在编辑界面）。
+        // approval.planFeedback 同 answer 系列：附意见的 toast 需直返 + 不落串行队列。
         if (actionValue.cmd === 'queue.input' ||
             actionValue.cmd === 'order.aliasInput' ||
             actionValue.cmd === 'order.aliasRemove' ||
+            actionValue.cmd === 'order.textInput' ||
             actionValue.cmd === 'config.save' ||
             actionValue.cmd === 'approval.respond' ||
             actionValue.cmd === 'approval.toggle' ||
             actionValue.cmd === 'approval.answer' ||
             actionValue.cmd === 'approval.answerSubmit' ||
             actionValue.cmd === 'approval.answerCustom' ||
-            actionValue.cmd === 'approval.answerNote') {
+            actionValue.cmd === 'approval.answerNote' ||
+            actionValue.cmd === 'approval.planFeedback') {
             return router.handleCardAction(fullValue, { userId, chatId, messageId });
         }
         // order.exec → equivalent queued message (Plan A): resolve the order text

package/dist/order/index.d.ts

@@ -22,6 +22,14 @@ export declare class OrderStore {
     private persist;
     save(text: string): OrderEntry;
     updateUsedAt(id: string): void;
+    /**
+     * 修改指令文本。保留 usedAt / alias / createdAt（编辑不应重置使用统计或别名）。
+     * newText===oldText 短路 persist，避免空写盘。长度 > MAX_TEXT_LENGTH 抛错（与 save 一致）。
+     * 内部统一 trim：卡片（handleOrderTextInput）与 CLI（/order edit）都直接传原始文本，
+     * 避免双 trim 语义混淆、也避免两条入口存出不同结果。纯空白（trim 后空）抛错。
+     * @returns 更新后的 entry；id 不存在返回 undefined。
+     */
+    updateText(id: string, newText: string): OrderEntry | undefined;
     /**
      * 给指令绑定别名（或解绑）。别名全局唯一，撞名抛错；名称必须通过
      * `ALIAS_NAME_PATTERN`（字母/数字/下划线、不能数字开头、≤20 字符）。

package/dist/order/index.js

@@ -84,6 +84,30 @@ export class OrderStore {
             this.persist();
         }
     }
+    /**
+     * 修改指令文本。保留 usedAt / alias / createdAt（编辑不应重置使用统计或别名）。
+     * newText===oldText 短路 persist，避免空写盘。长度 > MAX_TEXT_LENGTH 抛错（与 save 一致）。
+     * 内部统一 trim：卡片（handleOrderTextInput）与 CLI（/order edit）都直接传原始文本，
+     * 避免双 trim 语义混淆、也避免两条入口存出不同结果。纯空白（trim 后空）抛错。
+     * @returns 更新后的 entry；id 不存在返回 undefined。
+     */
+    updateText(id, newText) {
+        const trimmed = newText.trim();
+        if (trimmed === '') {
+            throw new Error('指令文本不能为空');
+        }
+        if (trimmed.length > MAX_TEXT_LENGTH) {
+            throw new Error(`指令文本超过 ${MAX_TEXT_LENGTH} 字符限制`);
+        }
+        const entry = this.data.find((e) => e.id === id);
+        if (!entry)
+            return undefined;
+        if (entry.text === trimmed)
+            return entry; // no-op: 短路 persist
+        entry.text = trimmed;
+        this.persist();
+        return entry;
+    }
     /**
      * 给指令绑定别名（或解绑）。别名全局唯一，撞名抛错；名称必须通过
      * `ALIAS_NAME_PATTERN`（字母/数字/下划线、不能数字开头、≤20 字符）。

package/dist/router/index.d.ts

@@ -308,6 +308,22 @@ export declare class CommandRouter {
     private handleOrderAliasInput;
     /** Handle order.aliasRemove: 删除某条指令的别名并原地重渲染列表卡。 */
     private handleOrderAliasRemove;
+    /**
+     * Handle order.textEdit: 展示指令文本编辑卡（input + ✓ 提交图标）。
+     * 预填当前 text（完整内容，不截断——input 组件有自有滚动条）；
+     * 提交 `order.textInput` 处理（trim + 长度校验 + OrderStore.updateText）。
+     * 完全镜像 handleOrderAliasEdit 的 4 段结构（reload → find → 构造 editCard →
+     * updateCardInPlace）。
+     */
+    private handleOrderTextEdit;
+    /**
+     * Handle order.textInput: 提交指令文本编辑。校验 orderId → OrderStore.updateText
+     * （store 内部统一 trim + 空/超长校验）。成功 toast + 原地重渲染列表卡（同
+     * handleOrderAliasInput 语义：toast-only 响应会让飞书停留在 pre-click 编辑卡，
+     * 必须把 card 放进 callback 响应体）；失败仅 error toast。
+     * 保留 usedAt / alias / createdAt（OrderStore.updateText 只动 text 字段）。
+     */
+    private handleOrderTextInput;
     /**
      * Handle ws.use card action: switch to the workspace, then refresh the /ws
      * list card in place so "recent" sort order is immediately visible.

package/dist/router/index.js

@@ -115,6 +115,8 @@ export function isImmediateAction(cmd) {
         cmd === 'order.aliasEdit' ||
         cmd === 'order.aliasInput' ||
         cmd === 'order.aliasRemove' ||
+        cmd === 'order.textEdit' ||
+        cmd === 'order.textInput' ||
         cmd === 'config.toggle' ||
         cmd === 'config.set' ||
         cmd === 'config.input' ||
@@ -367,6 +369,10 @@ export class CommandRouter {
                 return await this.handleOrderAliasInput(value, ctx);
             case 'order.aliasRemove':
                 return await this.handleOrderAliasRemove(value, ctx);
+            case 'order.textEdit':
+                return await this.handleOrderTextEdit(value, ctx);
+            case 'order.textInput':
+                return await this.handleOrderTextInput(value, ctx);
             case 'config.toggle':
             case 'config.set':
             case 'config.input':
@@ -1321,6 +1327,122 @@ export class CommandRouter {
             card: { type: 'raw', data: result.card },
         };
     }
+    /**
+     * Handle order.textEdit: 展示指令文本编辑卡（input + ✓ 提交图标）。
+     * 预填当前 text（完整内容，不截断——input 组件有自有滚动条）；
+     * 提交 `order.textInput` 处理（trim + 长度校验 + OrderStore.updateText）。
+     * 完全镜像 handleOrderAliasEdit 的 4 段结构（reload → find → 构造 editCard →
+     * updateCardInPlace）。
+     */
+    async handleOrderTextEdit(value, ctx) {
+        const orderId = value.orderId;
+        const offset = Math.max(0, Math.trunc(Number(value.offset) || 0));
+        if (!orderId) {
+            return { toast: { type: 'error', content: '卡片 payload 缺少必要信息' } };
+        }
+        this.orderStore.reload();
+        const order = this.orderStore.get().find((o) => o.id === orderId);
+        if (!order) {
+            return { toast: { type: 'error', content: '指令不存在或已被删除' } };
+        }
+        // 列表卡显示的是截断版（≤100 字符 + ...），编辑卡预览也保持一致；
+        // input 组件 default_value 预填完整 text（不受截断影响），用户提交后生效完整文本。
+        const displayText = order.text.length > 100 ? order.text.slice(0, 97) + '...' : order.text;
+        // CardKit 2.0 input 自带 ✓ 提交图标（input_value 经 raw 回传，红线）。
+        // 不用 form 容器（触发 300123 无 submit button / 200621 嵌套 column）。
+        const editCard = {
+            schema: '2.0',
+            config: { wide_screen_mode: true },
+            header: {
+                template: 'blue',
+                title: { tag: 'plain_text', content: '✏️ 编辑指令' },
+            },
+            body: {
+                elements: [
+                    {
+                        tag: 'div',
+                        text: { tag: 'lark_md', content: `**当前指令:**\n\`${displayText}\`` },
+                    },
+                    { tag: 'hr' },
+                    {
+                        tag: 'div',
+                        text: {
+                            tag: 'lark_md',
+                            content: '💡 修改后点击右侧 ✓ 提交；空白提交 = 报错；最多 200 字符',
+                        },
+                    },
+                    {
+                        tag: 'column_set',
+                        columns: [
+                            {
+                                tag: 'column',
+                                width: 'weighted',
+                                weight: 3,
+                                elements: [
+                                    {
+                                        tag: 'input',
+                                        name: 'text',
+                                        placeholder: { tag: 'plain_text', content: '输入新的指令文本...' },
+                                        default_value: order.text,
+                                        // max_length 与 MAX_TEXT_LENGTH=200 对齐：超长在输入侧直接截断，
+                                        // 避免提交后才报错（后端 updateText 仍会二次校验，双保险）。
+                                        max_length: 200,
+                                        behaviors: [
+                                            {
+                                                type: 'callback',
+                                                value: { cmd: 'order.textInput', orderId, offset },
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        };
+        await this.bridge.updateCardInPlace(editCard, ctx);
+    }
+    /**
+     * Handle order.textInput: 提交指令文本编辑。校验 orderId → OrderStore.updateText
+     * （store 内部统一 trim + 空/超长校验）。成功 toast + 原地重渲染列表卡（同
+     * handleOrderAliasInput 语义：toast-only 响应会让飞书停留在 pre-click 编辑卡，
+     * 必须把 card 放进 callback 响应体）；失败仅 error toast。
+     * 保留 usedAt / alias / createdAt（OrderStore.updateText 只动 text 字段）。
+     */
+    async handleOrderTextInput(value, ctx) {
+        const orderId = value.orderId;
+        const offset = Math.max(0, Math.trunc(Number(value.offset) || 0));
+        const raw = value.inputValue ?? value.formValue?.['text'];
+        if (!orderId) {
+            return { toast: { type: 'error', content: '卡片 payload 缺少必要信息' } };
+        }
+        this.orderStore.reload();
+        const order = this.orderStore.get().find((o) => o.id === orderId);
+        if (!order) {
+            return { toast: { type: 'error', content: '指令不存在或已被删除' } };
+        }
+        let updated;
+        try {
+            updated = this.orderStore.updateText(order.id, raw ?? '');
+        }
+        catch (err) {
+            return { toast: { type: 'error', content: err.message } };
+        }
+        if (!updated) {
+            // reload + find 后 updateText 不应返回 undefined；防御性兜底（如并发删除）。
+            return { toast: { type: 'error', content: '指令不存在或已被删除' } };
+        }
+        // 成功：重渲染列表卡（保持页码）。必须把 card 放进 callback 响应体让飞书
+        // 原地替换 pre-click 编辑卡——toast-only 响应会停留在编辑界面（飞书保留
+        // 点击前那张卡），见 handleQueueInput / handleOrderAliasInput 同款注释。
+        const result = this.cmdOrder([], ctx, offset);
+        const preview = updated.text.length > 50 ? updated.text.slice(0, 50) + '...' : updated.text;
+        return {
+            toast: { type: 'success', content: `✅ 已更新指令: ${preview}` },
+            card: { type: 'raw', data: result.card },
+        };
+    }
     /**
      * Handle ws.use card action: switch to the workspace, then refresh the /ws
      * list card in place so "recent" sort order is immediately visible.
@@ -1897,8 +2019,8 @@ export class CommandRouter {
             { cmd: 'resume', label: '/resume /r [agent] [list|id|N]', desc: '列出或切换 Agent session' },
             {
                 cmd: 'order',
-                label: '/order /o save|list',
-                desc: '收藏指令 /order save，指令可起别名（卡片上 ＋别名）',
+                label: '/order /o save|list|edit',
+                desc: '收藏指令 /order save，编辑指令 /order edit <id|N> <新文本>，指令可起别名（卡片上 ＋别名）',
             },
         ];
         const bodyElements = [];
@@ -3550,6 +3672,31 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                                                     },
                                                 ],
                                             },
+                                            {
+                                                // 编辑：弹蓝色 header 输入卡（CardKit 2.0 input + ✓ 提交），
+                                                // 镜像 order.aliasEdit 流程。order.textEdit 是 control-only action
+                                                // （isImmediateAction 注册），不 spawn agent。
+                                                tag: 'column',
+                                                width: 'auto',
+                                                elements: [
+                                                    {
+                                                        tag: 'button',
+                                                        text: { tag: 'plain_text', content: '编辑' },
+                                                        type: 'default',
+                                                        size: 'small',
+                                                        behaviors: [
+                                                            {
+                                                                type: 'callback',
+                                                                value: {
+                                                                    cmd: 'order.textEdit',
+                                                                    orderId: order.id,
+                                                                    offset: safeOffset,
+                                                                },
+                                                            },
+                                                        ],
+                                                    },
+                                                ],
+                                            },
                                             {
                                                 tag: 'column',
                                                 width: 'auto',
@@ -3648,8 +3795,30 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 return { text: `保存失败: ${err.message}` };
             }
         }
+        // /order edit <orderId|序号> <新文本> — CLI 备选路径（卡片是主入口）。
+        // 与 /order save / alias add|rm 对称；复用 resolveOrderTarget。
+        // 与卡片路径（handleOrderTextInput）对齐 trim 语义，避免「卡片 trim、CLI 不 trim」
+        // 两条入口对同一文本存出不同结果。
+        if (sub === 'edit') {
+            const target = args[1];
+            const newText = args.slice(2).join(' ').trim();
+            if (!target || !newText) {
+                return { text: '用法: /order edit <orderId|序号> <新文本>' };
+            }
+            const order = this.resolveOrderTarget(target);
+            if (!order)
+                return { text: `指令不存在: ${target}` };
+            try {
+                this.orderStore.updateText(order.id, newText);
+                const preview = newText.length > 50 ? newText.slice(0, 50) + '...' : newText;
+                return { text: `✅ 已更新指令: ${preview}` };
+            }
+            catch (err) {
+                return { text: `保存失败: ${err.message}` };
+            }
+        }
         return {
-            text: '用法: /order [list|save <text>|alias add <orderId|序号> <别名名>|alias rm <orderId|序号>]',
+            text: '用法: /order [list|save <text>|edit <orderId|序号> <新文本>|alias add <orderId|序号> <别名名>|alias rm <orderId|序号>]',
         };
     }
     /** /order alias add：按 orderId 或列表序号（1 基）解析目标指令并绑定别名。 */

package/dist/runner/claude/session.js

@@ -312,6 +312,10 @@ export class ClaudeSession extends SpawningRunner {
         this.cwd = opts.cwd;
         this.autoApprove = false;
         this.pendingToolInputs.clear();
+        // 每次 run 独立：上次 run 会话内跟踪到的计划文件不得泄漏到本次
+        // （否则本次 ExitPlanMode 无 plan/planFilePath 时 resolvePlanContent
+        // 会误读上一次的计划文件当当前计划）。
+        this.planFilePath = '';
         let proc;
         try {
             proc = await this.spawnChild(opts);

package/dist/runner/common/acp/protocol-types.d.ts

@@ -39,7 +39,7 @@ export declare const RpcErrorCode: {
 export interface InitializeParams {
     /** Protocol version — must be 1 (number, not string). */
     protocolVersion: number;
-    /** Client capabilities: explicitly declare what we support (all off). */
+    /** Client capabilities: declare only reverse-RPC surfaces we implement. */
     clientCapabilities: {
         fs: {
             readTextFile: boolean;
@@ -209,6 +209,12 @@ export declare const ServerRequestMethod: {
     readonly REQUEST_PERMISSION: "session/request_permission";
     /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
     readonly ELICITATION_CREATE: "elicitation/create";
+    /** kimi terminal 工具 reverse RPC：Bash 执行下放客户端（acp-terminal）。 */
+    readonly TERMINAL_CREATE: "terminal/create";
+    readonly TERMINAL_OUTPUT: "terminal/output";
+    readonly TERMINAL_WAIT_FOR_EXIT: "terminal/wait_for_exit";
+    readonly TERMINAL_KILL: "terminal/kill";
+    readonly TERMINAL_RELEASE: "terminal/release";
 };
 export interface PermissionOption {
     /** Opaque option identifier — echo back in response outcome.optionId. */
@@ -269,3 +275,34 @@ export interface ElicitationCreateResponse {
     /** accept 时的答案，key 为 q0..qn（按问题顺序）。 */
     content?: Record<string, string | string[]>;
 }
+export interface TerminalCreateParams {
+    sessionId: string;
+    /** 恒为 'bash'（服务端 spawn 只接受 bash -c）。 */
+    command: string;
+    /** ['-c', <script>]：-c 在 args[0]，脚本在 args[1]。 */
+    args: string[];
+    env?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** 可能为 null → 回退 session cwd。 */
+    cwd?: string | null;
+    /** 输出缓冲上限（字节），默认 4MB。 */
+    outputByteLimit?: number;
+}
+export interface TerminalOutputParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalWaitForExitParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalKillParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalReleaseParams {
+    sessionId: string;
+    terminalId: string;
+}

package/dist/runner/common/acp/protocol-types.js

@@ -73,5 +73,11 @@ export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',
     /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
     ELICITATION_CREATE: 'elicitation/create',
+    /** kimi terminal 工具 reverse RPC：Bash 执行下放客户端（acp-terminal）。 */
+    TERMINAL_CREATE: 'terminal/create',
+    TERMINAL_OUTPUT: 'terminal/output',
+    TERMINAL_WAIT_FOR_EXIT: 'terminal/wait_for_exit',
+    TERMINAL_KILL: 'terminal/kill',
+    TERMINAL_RELEASE: 'terminal/release',
 };
 //# sourceMappingURL=protocol-types.js.map

package/dist/runner/dsh/runner.d.ts

@@ -44,6 +44,13 @@ export declare class DshRunner implements AgentRunner {
     private activeAbort;
     private activeSessionId;
     private running;
+    /**
+     * 已对齐模型的 session 集合：同一 session 二次 run 不再重发 selectModel
+     * （session.selectModel 会写服务端全局默认，每次 run 都写是写放大）。
+     * configuredModel 在实例生命周期内不变（/config 改模型会 clearRunners
+     * 重建实例 + 换新 sessionId），故「每 session 对齐一次」足以覆盖配置变化。
+     */
+    private readonly alignedSessions;
     constructor(opts: DshRunnerOptions);
     get isRunning(): boolean;
     getStatusInfo(): AgentStatusInfo;

package/dist/runner/dsh/runner.js

@@ -28,6 +28,13 @@ export class DshRunner {
     activeAbort = null;
     activeSessionId = null;
     running = false;
+    /**
+     * 已对齐模型的 session 集合：同一 session 二次 run 不再重发 selectModel
+     * （session.selectModel 会写服务端全局默认，每次 run 都写是写放大）。
+     * configuredModel 在实例生命周期内不变（/config 改模型会 clearRunners
+     * 重建实例 + 换新 sessionId），故「每 session 对齐一次」足以覆盖配置变化。
+     */
+    alignedSessions = new Set();
     constructor(opts) {
         this.sessionReader = opts.sessionReader;
         this.configuredModel = opts.model;
@@ -70,9 +77,32 @@ export class DshRunner {
                 sessionId = created.sessionId;
             }
             this.activeSessionId = sessionId;
-            // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
-            // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
-            if (this.configuredModel) {
+            // Startup abort：createSession 挂起期间 stop() 已 abort（此时 sessionId 尚
+            // 未知，stop() 无法 cancel）。createSession 返回后立即检查——已 abort 则
+            // cancel 这个刚建的 session 并中断，不让启动流程继续（selectModel/prompt）。
+            // 必须 yield interrupted result（不能裸 return）：调用方依赖 result 收尾
+            // run 卡，否则 for-await 自然结束后无终态、卡片停留「运行中」。
+            if (abort.signal.aborted) {
+                try {
+                    await this.client.unary('session.cancel', { sessionId });
+                }
+                catch {
+                    /* 取消失败仅告警，session 已 abort 无需继续 */
+                }
+                getLogger().info(`[dsh] run aborted during startup, cancelled session ${sessionId}`);
+                terminalEmitted = true;
+                yield {
+                    type: 'result',
+                    subtype: 'interrupted',
+                    session_id: sessionId,
+                    errorMessage: 'run stopped',
+                };
+                return;
+            }
+            // 模型/推理强度对齐（§4.3）：会话首次 run 时 selectModel 一次
+            // （该调用同时写服务端全局默认，故不重复写）；同一 session 后续 run
+            // 跳过。失败仅告警不阻断 run（模型校验由 DSH 负责）。
+            if (this.configuredModel && !this.alignedSessions.has(sessionId)) {
                 try {
                     await this.client.selectModel({
                         sessionId,
@@ -80,6 +110,7 @@ export class DshRunner {
                         model: this.configuredModel,
                         ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
                     });
+                    this.alignedSessions.add(sessionId);
                 }
                 catch (err) {
                     getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);

package/dist/runner/kimi/acp/runner.d.ts

@@ -46,6 +46,21 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     private readonly compactPollTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     private pendingApprovals;
+    /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    private terminals;
+    /** terminalId 自增序号（term-1, term-2, …）。 */
+    private terminalSeq;
+    /**
+     * kimi 服务端对 Bash 工具的 tool_call/tool_call_update 通知（title='Bash'）。
+     * Bash 的真实执行走 terminal/* reverse RPC 下放客户端，tool 事件由本 runner
+     * 自产（tool_use 带命令、tool_result 带本地输出）；这些通知必须过滤，否则
+     * 卡片出现双份 Bash 面板（通知版无 rawInput、terminal embed 无 rawOutput，
+     * 只能渲染「_无输出_」）。收集到的 toolCallId 用于过滤对应的 update。
+     */
+    private bashToolCallIds;
+    /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
+    private activeCwd;
+    private readonly processStopper;
     /** Tracker for the in-flight prompt request — needed for cancellation. */
     private promptSettled;
     constructor(opts: KimiAcpRunnerOptions);
@@ -102,5 +117,41 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
      */
     private waitForCompactionRecord;
     private handleNotification;
+    /**
+     * Filter kimi's own Bash tool notifications so the run card doesn't get a
+     * duplicate, output-less Bash panel alongside the runner-produced one.
+     *
+     * - tool_call title='Bash' → remember the toolCallId, drop the notification
+     *   (the tool_use comes from terminal/create with the real command).
+     * - tool_call_update for a remembered id → drop (streaming args deltas and
+     *   the terminal embed final update; the tool_result is emitted locally).
+     * Returns true when the notification should be swallowed.
+     */
+    private filterBashNotifications;
     private handleServerRequest;
+    /**
+     * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
+     *
+     * 契约（kimi-code acp-terminal/acpTerminalRunner.ts）：
+     *   create → 立即回 {terminalId}，进程异步跑，不阻塞 RPC；
+     *   output → 回累计 stdout（非增量，服务端按 emitted 偏移切片）；
+     *   wait_for_exit → 未退出则等 exit 再回 {exitCode, signal}；
+     *   kill/release → 杀进程并回 {}。
+     */
+    private handleTerminalRequest;
+    /**
+     * terminal/create: spawn 一次性进程（bash -c <script>），流式累积
+     * stdout(+stderr) 到缓冲，立即回 {terminalId}。
+     */
+    private handleTerminalCreate;
+    /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
+    private handleTerminalOutput;
+    /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */
+    private handleTerminalWaitForExit;
+    /** terminal/kill: 立即杀进程组，回 {}。 */
+    private handleTerminalKill;
+    /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
+    private handleTerminalRelease;
+    /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
+    private cleanupTerminals;
 }

package/dist/runner/kimi/acp/runner.js

@@ -11,19 +11,31 @@
  * pattern, same forceFinish/stopRequested semantics, same turn idle timeout,
  * same ConnectionLostError retry.
  */
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager as KimiAcpConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
-import { RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
+import { NotificationMethod, RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
 import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import { ProcessStopper } from '../../common/process-stopper.js';
 /** R2: how long to wait for the background compaction record after the
  *  /compact prompt settles (design doc §6.1). Real kimi 0.36.0 lands
  *  context.apply_compaction ~8s after end_turn. */
 const COMPACT_POLL_TIMEOUT_MS = 30_000;
 /** Poll interval for the wire.jsonl compaction record. */
 const COMPACT_POLL_INTERVAL_MS = 1_000;
+// =============================================================================
+// kimi terminal 工具（Bash 执行下放客户端）
+// 契约：kimi-code/packages/acp-server/src/acp-terminal/acpTerminalRunner.ts
+//   一次性 bash -c <script>，非交互 PTY、无 stdin；服务端每 250ms 轮询
+//   terminal/output，客户端只回累计 stdout。创建/轮询/等待/杀/释放五个
+//   reverse RPC 全部由本 runner 本地 spawn 子进程实现。
+// =============================================================================
+/** terminal/create 未显式给 outputByteLimit 时的缓冲上限（对齐服务端默认 4MB）。 */
+const TERMINAL_DEFAULT_OUTPUT_LIMIT = 4 * 1024 * 1024;
 /**
  * Map user-facing permission mode to ACP mode id.
  *
@@ -162,6 +174,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     compactPollTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     pendingApprovals = new Map();
+    /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    terminals = new Map();
+    /** terminalId 自增序号（term-1, term-2, …）。 */
+    terminalSeq = 0;
+    /**
+     * kimi 服务端对 Bash 工具的 tool_call/tool_call_update 通知（title='Bash'）。
+     * Bash 的真实执行走 terminal/* reverse RPC 下放客户端，tool 事件由本 runner
+     * 自产（tool_use 带命令、tool_result 带本地输出）；这些通知必须过滤，否则
+     * 卡片出现双份 Bash 面板（通知版无 rawInput、terminal embed 无 rawOutput，
+     * 只能渲染「_无输出_」）。收集到的 toolCallId 用于过滤对应的 update。
+     */
+    bashToolCallIds = new Set();
+    /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
+    activeCwd = null;
+    processStopper = new ProcessStopper({ graceMs: 2_000 });
     /** Tracker for the in-flight prompt request — needed for cancellation. */
     promptSettled = false;
     constructor(opts) {
@@ -178,8 +205,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             initializeParams: {
                 protocolVersion: 1,
                 clientCapabilities: {
+                    // fs 保持关闭：kimi 服务端在 fs 能力为 false 时走本地磁盘兜底
+                    // （acpFsService.ts AcpHostFileSystem.inner），kimi 是本地子进程，
+                    // 本地盘即工作区盘，读写正常；声明 true 则服务端改发 fs/* reverse
+                    // RPC，lark-remote 未实现该面，文件读写会 METHOD_NOT_FOUND 失败。
                     fs: { readTextFile: false, writeTextFile: false },
-                    terminal: false,
+                    // terminal 常开：yolo/auto 自主跑命令；manual 走 session/request_permission 审批。
+                    terminal: true,
                     // AskUserQuestion 走 elicitation form（原生多题+多选；form 失败时
                     // kimi 服务端自动回退 request_permission 桥，客户端两者都处理）。
                     // 注意：ACP SDK 对 elicitation.form 的 zod schema 是对象
@@ -223,6 +255,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.currentTranslator = null;
         this.promptSettled = false;
         this.activeSessionId = null;
+        this.activeCwd = null;
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -231,6 +264,8 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.connectionManager.notifyIdle(cwd);
     }
     async disposeConnections() {
+        // 关闭前 kill/release 所有存活 terminal，避免孤儿 bash 进程。
+        await this.cleanupTerminals();
         await this.connectionManager.disposeAll();
     }
     /**
@@ -245,10 +280,14 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             const client = await this.connectionManager.acquire(opts.cwd);
             this.connectionManager.notifyActivity(opts.cwd);
             this.currentClient = client;
+            this.activeCwd = opts.cwd;
             client.setHooks({
                 onNotification: (method, params) => this.handleNotification(method, params),
                 onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-                onClose: () => this.failTurn('Kimi ACP connection closed'),
+                onClose: () => {
+                    void this.cleanupTerminals();
+                    this.failTurn('Kimi ACP connection closed');
+                },
             });
             const sessionId = opts.sessionId;
             if (!sessionId) {
@@ -382,11 +421,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         const client = await this.connectionManager.acquire(opts.cwd);
         this.connectionManager.notifyActivity(opts.cwd);
         this.currentClient = client;
+        this.activeCwd = opts.cwd;
         client.setHooks({
             onNotification: (method, params) => this.handleNotification(method, params),
             onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
             onClose: () => {
                 getLogger().warn(`[${this.logTag}] client connection closed`);
+                void this.cleanupTerminals();
                 this.failTurn('Kimi ACP connection closed');
             },
         });
@@ -494,10 +535,61 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         getLogger().warn(`[${this.logTag}] compaction record not observed within ${this.compactPollTimeoutMs}ms (baseline=${baselineCount}); proceeding without confirmation`);
     }
     handleNotification(method, params) {
+        // Terminal-backed Bash 的通知走 runner 自产事件（见 bashToolCallIds），
+        // 不交给 translator；其余通知（Read/Edit/text/thinking）正常翻译。
+        if (method === NotificationMethod.SESSION_UPDATE && this.filterBashNotifications(params)) {
+            return;
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }
+    /**
+     * Filter kimi's own Bash tool notifications so the run card doesn't get a
+     * duplicate, output-less Bash panel alongside the runner-produced one.
+     *
+     * - tool_call title='Bash' → remember the toolCallId, drop the notification
+     *   (the tool_use comes from terminal/create with the real command).
+     * - tool_call_update for a remembered id → drop (streaming args deltas and
+     *   the terminal embed final update; the tool_result is emitted locally).
+     * Returns true when the notification should be swallowed.
+     */
+    filterBashNotifications(params) {
+        if (typeof params !== 'object' || params === null)
+            return false;
+        const update = params.update;
+        if (!update || typeof update !== 'object')
+            return false;
+        if (update.sessionUpdate === 'tool_call') {
+            if (update.title === 'Bash') {
+                if (typeof update.toolCallId === 'string') {
+                    this.bashToolCallIds.add(update.toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        if (update.sessionUpdate === 'tool_call_update') {
+            const toolCallId = update.toolCallId;
+            if (typeof toolCallId === 'string' && this.bashToolCallIds.has(toolCallId)) {
+                // 终态后清掉 id，避免集合随会话无限增长（漏清无碍：id 全局唯一）。
+                if (update.status === 'completed' || update.status === 'failed') {
+                    this.bashToolCallIds.delete(toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
     handleServerRequest(id, method, params) {
+        // kimi terminal 工具：Bash 执行下放客户端（acp-terminal reverse RPC）。
+        // 请求本身是纯 request/response I/O，不交给 translator（避免落入下方
+        // 「空事件 → 拒绝」兜底）；对应的 tool_use/tool_result 事件由
+        // handleTerminalCreate 自产（带本地命令与输出，见 bashToolCallIds）。
+        if (method.startsWith('terminal/')) {
+            void this.handleTerminalRequest(id, method, params);
+            return;
+        }
         const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
         if (events.length === 0) {
             // Unhandled/unsupported server request must be explicitly responded to
@@ -527,5 +619,221 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         }
         this.pushEvents(events);
     }
+    /**
+     * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
+     *
+     * 契约（kimi-code acp-terminal/acpTerminalRunner.ts）：
+     *   create → 立即回 {terminalId}，进程异步跑，不阻塞 RPC；
+     *   output → 回累计 stdout（非增量，服务端按 emitted 偏移切片）；
+     *   wait_for_exit → 未退出则等 exit 再回 {exitCode, signal}；
+     *   kill/release → 杀进程并回 {}。
+     */
+    async handleTerminalRequest(id, method, params) {
+        try {
+            switch (method) {
+                case ServerRequestMethod.TERMINAL_CREATE:
+                    this.handleTerminalCreate(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_OUTPUT:
+                    this.handleTerminalOutput(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_WAIT_FOR_EXIT:
+                    await this.handleTerminalWaitForExit(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_KILL:
+                    await this.handleTerminalKill(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_RELEASE:
+                    await this.handleTerminalRelease(id, params);
+                    return;
+                default:
+                    this.currentClient?.respondError(id, RpcErrorCode.METHOD_NOT_FOUND, `Unsupported server request: ${method}`);
+            }
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] terminal request failed method=${method}: ${err.message}`);
+            this.currentClient?.respondError(id, RpcErrorCode.INTERNAL_ERROR, `Terminal request failed: ${err.message}`);
+        }
+    }
+    /**
+     * terminal/create: spawn 一次性进程（bash -c <script>），流式累积
+     * stdout(+stderr) 到缓冲，立即回 {terminalId}。
+     */
+    handleTerminalCreate(id, params) {
+        const env = params.env
+            ? Object.fromEntries(params.env.map((e) => [e.name, e.value]))
+            : undefined;
+        const cwd = params.cwd ?? this.activeCwd ?? undefined;
+        const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
+        const proc = spawn(params.command, params.args ?? [], {
+            cwd,
+            env: env ? { ...process.env, ...env } : undefined,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // ProcessStopper 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
+            // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
+            // 与 JsonlRpcTransport / spawning-runner 的 detached:true 同模式。
+            detached: true,
+        });
+        // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
+        // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
+        const stdoutDecoder = new StringDecoder('utf8');
+        const stderrDecoder = new StringDecoder('utf8');
+        const append = (chunk, decoder) => {
+            if (handle.truncated)
+                return;
+            const remaining = handle.outputLimit - handle.outputBytes;
+            if (remaining > 0 && chunk.length <= remaining) {
+                handle.output += decoder.write(chunk);
+                handle.outputBytes += chunk.length;
+            }
+            else if (remaining > 0) {
+                // 只喂 remaining 字节；decoder 内部保留末尾不完整序列，不会在字节
+                // 边界产生替换符。outputBytes 按「喂入字节」计，保证不超过上限。
+                handle.output += decoder.write(chunk.subarray(0, remaining));
+                handle.outputBytes += remaining;
+            }
+            // 契约（手册）：truncated = 缓冲 >= limit——恰好填满也标 true。
+            if (handle.outputBytes >= handle.outputLimit)
+                handle.truncated = true;
+        };
+        proc.stdout?.on('data', (chunk) => append(chunk, stdoutDecoder));
+        proc.stderr?.on('data', (chunk) => append(chunk, stderrDecoder));
+        // spawn 失败（如 ENOENT）只发 'error' 不发 'exit'——一并 resolve，防止
+        // wait_for_exit 永久挂起（runner 层 ENOENT 兜底红线）。
+        // 用 resolveExit 承接，避免回调在 handle 初始化前引用它（TDZ）。
+        let resolveExit;
+        const exitPromise = new Promise((resolve) => {
+            resolveExit = resolve;
+        });
+        // 与 resolveExit 同款 TDZ 规避：tool_result 发射闭包在 terminalId 初始化
+        // 后赋值，exit/error 回调执行时经 emitResult 间接调用。
+        let emitTerminalResult = undefined;
+        const emitResult = () => {
+            emitTerminalResult?.();
+        };
+        const handle = {
+            proc,
+            output: '',
+            outputBytes: 0,
+            outputLimit,
+            truncated: false,
+            exitCode: null,
+            signal: null,
+            exitPromise,
+        };
+        proc.once('exit', (code, signal) => {
+            handle.exitCode = code;
+            handle.signal = signal;
+            resolveExit?.();
+            emitResult();
+        });
+        proc.once('error', (err) => {
+            getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
+            if (handle.exitCode === null && handle.signal === null) {
+                handle.exitCode = 1;
+                handle.signal = null;
+            }
+            resolveExit?.();
+            emitResult();
+        });
+        const terminalId = `term-${++this.terminalSeq}`;
+        this.terminals.set(terminalId, handle);
+        // Bash 工具事件由本 runner 自产（kimi 通知已过滤）：create 即推 tool_use
+        // 带真实命令，让 run 卡立刻出现可识别的 Bash 面板。
+        const script = Array.isArray(params.args) && params.args.length > 1 ? params.args[1] : params.command;
+        let resultEmitted = false;
+        emitTerminalResult = () => {
+            if (resultEmitted)
+                return;
+            resultEmitted = true;
+            this.pushEvents([
+                {
+                    type: 'user',
+                    message: {
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: terminalId,
+                                content: handle.output,
+                                is_error: handle.exitCode !== 0,
+                            },
+                        ],
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+            ]);
+        };
+        this.pushEvents([
+            {
+                type: 'assistant',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: terminalId,
+                            name: 'Bash',
+                            input: { command: script, cwd },
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ]);
+        getLogger().info(`[${this.logTag}] terminal created id=${terminalId} command=${params.command} args=${JSON.stringify(params.args ?? [])}`);
+        this.currentClient?.respond(id, { terminalId });
+    }
+    /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
+    handleTerminalOutput(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.currentClient?.respond(id, {
+            output: handle.output,
+            truncated: handle.truncated,
+            exitStatus: { exitCode: handle.exitCode, signal: handle.signal },
+        });
+    }
+    /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */
+    async handleTerminalWaitForExit(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await handle.exitPromise;
+        this.currentClient?.respond(id, { exitCode: handle.exitCode, signal: handle.signal });
+    }
+    /** terminal/kill: 立即杀进程组，回 {}。 */
+    async handleTerminalKill(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
+    async handleTerminalRelease(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.terminals.delete(params.terminalId);
+        // stop 对已退出进程是 no-op；仍在跑则立即 SIGTERM+SIGKILL。
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
+    async cleanupTerminals() {
+        const handles = [...this.terminals.values()];
+        this.terminals.clear();
+        for (const handle of handles) {
+            await this.processStopper.stop(handle.proc, { immediate: true });
+        }
+    }
 }
 //# sourceMappingURL=runner.js.map

package/dist/runner/registry.d.ts

@@ -5,8 +5,9 @@ import type { AgentKind, Runner } from './index.js';
  * up `config.defaultAgent` here to pick the concrete runner.
  *
  * Singleton caching: the factory MAY cache its instance internally. Most
- * current agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
- * workspace-lifetime (app-server). Each factory returns a runner per call.
+ * current spawn-type agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
+ * workspace-lifetime (app-server); dsh is HTTP+WS direct connection (no local
+ * subprocess). Each factory returns a runner per call.
  *
  * Dynamic config reload: factory can read latest config via registry's
  * configContainer, enabling runtime config changes to take effect.

package/dist/runner/registry.js

@@ -9,8 +9,9 @@ let globalRegistry;
  * up `config.defaultAgent` here to pick the concrete runner.
  *
  * Singleton caching: the factory MAY cache its instance internally. Most
- * current agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
- * workspace-lifetime (app-server). Each factory returns a runner per call.
+ * current spawn-type agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
+ * workspace-lifetime (app-server); dsh is HTTP+WS direct connection (no local
+ * subprocess). Each factory returns a runner per call.
  *
  * Dynamic config reload: factory can read latest config via registry's
  * configContainer, enabling runtime config changes to take effect.

package/dist/runner/types.d.ts

@@ -337,7 +337,7 @@ export interface SpawnOptions {
     settings?: string;
 }
 /**
- * Seam (§3): the contract any agent runner (claude/codex/opencode/pi/kimi)
+ * Seam (§3): the contract any agent runner (claude/codex/opencode/pi/kimi/dsh)
  * must satisfy for the router/bridge.
  * Declared here so callers depend on the interface, not the concrete
  * runner classes — test stubs satisfy this structurally.
@@ -474,7 +474,7 @@ export interface AgentRunner extends Runner {
 }
 /** Agent self-describing status info for /status display. */
 export interface AgentStatusInfo {
-    /** Agent kind (claude/codex/opencode/pi/kimi). */
+    /** Agent kind (claude/codex/opencode/pi/kimi/dsh). */
     kind: AgentKind;
     /** Display model name. */
     model: string;

package/dist/session/common/pagination.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared pagination / truncation helpers for agent session readers.
  *
- * The five readers (claude/codex/opencode/pi/kimi) all implement the same
+ * The six readers (claude/codex/opencode/pi/kimi/dsh) all implement the same
  * offset-clamp + slice + total pattern for `listSessions`, and the same
  * maxEvents tail-cap for `readSessionContent`. These were duplicated (and had
  * drifted on the default limit). Centralized here so the contract is defined

package/dist/session/common/pagination.js

@@ -1,7 +1,7 @@
 /**
  * Shared pagination / truncation helpers for agent session readers.
  *
- * The five readers (claude/codex/opencode/pi/kimi) all implement the same
+ * The six readers (claude/codex/opencode/pi/kimi/dsh) all implement the same
  * offset-clamp + slice + total pattern for `listSessions`, and the same
  * maxEvents tail-cap for `readSessionContent`. These were duplicated (and had
  * drifted on the default limit). Centralized here so the contract is defined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",