lark-remote 0.3.0 → 0.4.0

package/dist/connector/index.js

@@ -3,6 +3,7 @@ import { getLogger } from '../logger/index.js';
 import { MAX_FILE_UPLOAD_SIZE } from './file-limits.js';
 import { DEFAULT_INBOUND_MEDIA_MAX_SIZE_MB } from '../config/index.js';
 import { sleep } from '../common/sleep.js';
+import { isTransientTransportError } from '../error-classification.js';
 import axios from 'axios';
 import fs from 'node:fs';
 import { silentlyUnlink } from '../common/fs.js';
@@ -88,6 +89,72 @@ function shouldRetrySendError(err) {
         return true;
     return false;
 }
+/**
+ * 卡片 patch 的重试上限。含义：1 次原始尝试 + 最多 PATCH_MAX_RETRIES 次重试。
+ */
+export const PATCH_MAX_RETRIES = 3;
+/** 重试退避基数（ms）；第 n 次重试前等待 n × 基数，给对端恢复的时间。 */
+export const PATCH_RETRY_BASE_DELAY_MS = 150;
+/** 记日志用的错误摘要（不打印 axios 巨型循环对象）。 */
+function formatErrorForLog(err) {
+    if (err instanceof Error) {
+        // For axios errors, extract useful info without circular refs
+        const axiosErr = err;
+        if (axiosErr.response?.status) {
+            return `${err.message} (HTTP ${axiosErr.response.status})`;
+        }
+        if (axiosErr.code) {
+            return `${err.message} (code: ${axiosErr.code})`;
+        }
+        return err.message;
+    }
+    return String(err);
+}
+/**
+ * 卡片 patch 是否值得重试：传输层瞬态失败 + 5xx。
+ * 4xx（业务拒绝/请求构造错误）不重试 —— 重试只会得到同样的结果。
+ */
+function isRetryablePatchError(err) {
+    if (isTransientTransportError(err))
+        return true;
+    if (err == null || typeof err !== 'object')
+        return false;
+    const status = err.response?.status;
+    return typeof status === 'number' && status >= 500 && status < 600;
+}
+/**
+ * 带重试的 `im.v1.message.patch`。
+ *
+ * 为什么必须在这一层重试：流式卡片的 patch 由 @larksuite/channel 的
+ * CardStreamController 经 throttle 延迟触发 —— `controller.update()` 调完
+ * `throttle.note()` 就 resolve，不等真正的 patch。失败时是一条脱离 await 链的
+ * detached rejection，只能冒泡到 `process.unhandledRejection`，调用方的
+ * try/catch 根本挡不住。2026-09-15 00:09 的事故正是如此：卡片 patch 时
+ * socket 被关（AxiosError `ERR_SOCKET_CLOSED`），整进程退出，正在跑的 run 陪葬。
+ *
+ * 这里在唯一的底层 patch 出口上兜住：瞬态错误重试最多 PATCH_MAX_RETRIES 次，
+ * 全部失败才把最后一个错误抛出去（此时上层 classifyRejection 也会判为
+ * recoverable，不会击穿进程）。patch 是整卡替换，重试天然幂等。
+ */
+async function patchWithRetry(patchFn, request, options) {
+    let lastError;
+    for (let attempt = 0; attempt <= PATCH_MAX_RETRIES; attempt += 1) {
+        try {
+            return await patchFn(request, options);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt === PATCH_MAX_RETRIES || !isRetryablePatchError(err))
+                throw err;
+            const delayMs = PATCH_RETRY_BASE_DELAY_MS * (attempt + 1);
+            getLogger().warn(`[feishu] message.patch transient failure ` +
+                `(attempt ${attempt + 1}/${PATCH_MAX_RETRIES + 1}), retrying in ${delayMs}ms: ` +
+                `${formatErrorForLog(err)}`);
+            await sleep(delayMs);
+        }
+    }
+    throw lastError;
+}
 /**
  * Safely extract the im.v1.message.patch service from a LarkChannel.
  * Returns undefined when the channel mock omits rawClient (unit tests).
@@ -126,16 +193,19 @@ export class FeishuConnector {
                 },
             },
         });
-        // 观测探针（2026-08-11 run 卡定格事故）：飞书业务码错误以 HTTP 200 + {code!=0}
-        // 返回时，lark SDK 正常 resolve、@larksuite/channel 的 patchCard 丢弃返回值，
-        // 导致终态卡 patch 被业务层拒绝时全链路无日志无兜底。这里只观测不改行为——
-        // 不 throw、不重试，返回值原样透传。
+        // 卡片 patch 的统一出口（观测 + 重试）：
+        // 1) 观测（2026-08-11 run 卡定格事故）：飞书业务码错误以 HTTP 200 + {code!=0}
+        //    返回时，lark SDK 正常 resolve、@larksuite/channel 的 patchCard 丢弃返回值，
+        //    导致终态卡 patch 被业务层拒绝时全链路无日志无兜底。这里把业务码记 warn，
+        //    返回值原样透传。
+        // 2) 重试（2026-09-15 socket-close 事故）：瞬态传输失败就地重试，最多
+        //    PATCH_MAX_RETRIES 次，不把失败直接落到 unhandledRejection 打死进程。
         // Guard: unit-test mocks may omit rawClient; skip probe installation in that case.
         const messageService = tryGetPatchService(this.channel);
         if (messageService?.patch) {
             const origPatch = messageService.patch.bind(messageService);
             messageService.patch = (async (request, options) => {
-                const res = await origPatch(request, options);
+                const res = await patchWithRetry(origPatch, request, options);
                 if (typeof res?.code === 'number' && res.code !== 0) {
                     const content = request?.data?.content;
                     const bytes = typeof content === 'string' ? Buffer.byteLength(content, 'utf8') : undefined;
@@ -344,18 +414,7 @@ export class FeishuConnector {
     }
     /** Format error for logging without causing circular serialization */
     formatError(err) {
-        if (err instanceof Error) {
-            // For axios errors, extract useful info without circular refs
-            const axiosErr = err;
-            if (axiosErr.response?.status) {
-                return `${err.message} (HTTP ${axiosErr.response.status})`;
-            }
-            if (axiosErr.code) {
-                return `${err.message} (code: ${axiosErr.code})`;
-            }
-            return err.message;
-        }
-        return String(err);
+        return formatErrorForLog(err);
     }
     async addReaction(messageId, emoji) {
         try {

package/dist/error-classification.d.ts

@@ -11,5 +11,12 @@
  * （recoverable，记日志不 exit）还是「进程状态损坏」（fatal，exit）。
  */
 type RejectionVerdict = 'recoverable' | 'fatal';
+/**
+ * Whether `reason` is a transient transport failure (connection/socket level).
+ *
+ * Exported because the card-patch retry path needs the same judgement:
+ * one definition, so "retry" and "don't kill the process" never drift apart.
+ */
+export declare function isTransientTransportError(reason: unknown): boolean;
 export declare function classifyRejection(reason: unknown): RejectionVerdict;
 export {};

package/dist/error-classification.js

@@ -1,3 +1,36 @@
+/**
+ * 传输层瞬态错误码（Node errno + axios 包装码）。
+ *
+ * 这些错误代表"这次请求没送出去/连接断了"，重试或忽略都是安全的；
+ * 它们不携带任何"程序状态损坏"的信息。典型场景：本地 mitmdump 代理重启
+ * （ECONNREFUSED）、Wi-Fi 抖动（ENOTFOUND/EAI_AGAIN）、对端关连接
+ * （ECONNRESET/EPIPE/ERR_SOCKET_CLOSED）。
+ */
+const TRANSIENT_TRANSPORT_CODES = new Set([
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ECONNABORTED',
+    'EPIPE',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ERR_SOCKET_CLOSED',
+    'ERR_NETWORK',
+]);
+/**
+ * Whether `reason` is a transient transport failure (connection/socket level).
+ *
+ * Exported because the card-patch retry path needs the same judgement:
+ * one definition, so "retry" and "don't kill the process" never drift apart.
+ */
+export function isTransientTransportError(reason) {
+    if (reason == null || typeof reason !== 'object')
+        return false;
+    const code = reason.code;
+    return typeof code === 'string' && TRANSIENT_TRANSPORT_CODES.has(code);
+}
 export function classifyRejection(reason) {
     // Guard against null/undefined/primitive reasons: the `as` cast below is
     // TS-only (erased at runtime), so `null.response` would throw a TypeError
@@ -10,7 +43,10 @@ export function classifyRejection(reason) {
     const status = err.response?.status;
     if (status !== undefined && status >= 500 && status < 600)
         return 'recoverable';
-    if (err.code === 'ETIMEDOUT' || err.code === 'ECONNRESET')
+    // 传输层瞬态失败：连接/socket 级别，与进程状态无关。
+    // 2026-09-15 00:09 的崩溃就是这条漏了 —— AxiosError `ERR_SOCKET_CLOSED`
+    // （卡片 patch 时 socket 被关）落到 fatal → process.exit(1)，正在跑的 agent run 陪葬。
+    if (isTransientTransportError(reason))
         return 'recoverable';
     // 飞书 API 业务错误（如 230027 外部会话无权限）—— 经 SDK throttle detach 路径逃逸的
     // patch rejection。流式卡片是尽力而为的展示层，飞书侧业务拒绝不应击穿进程。

package/dist/index.js

@@ -19,6 +19,8 @@ import { OwnerBinder, formatBindGuidance } from './binder.js';
 import { CloneSession } from './clone.js';
 import { InstanceAlreadyRunningError, InstanceLock } from './instance-lock.js';
 import { spawnReplacementBridge, waitForPreviousInstance } from './restart.js';
+import { currentPlatform } from './platform/select.js';
+import { startSleepBlocker } from './platform/sleep-blocker.js';
 import { checkLatestVersion, isNewer, runInstallLatest, formatUpdateHint } from './update/index.js';
 import { classifyRejection } from './error-classification.js';
 import { WorkspaceStore } from './workspace/index.js';
@@ -622,9 +624,17 @@ async function main() {
     }
     const { config, configDir, logger, instanceLock } = await initializeCliAndConfig();
     // Restart handoff: if spawned as a /restart replacement, wait for the old
-    // bridge to die (and release the instance lock) before acquiring it.
+    // lark-remote to die (and release the instance lock) before acquiring it.
     await waitForPreviousInstance();
     setupInstanceLockAndHandlers(instanceLock, logger, configDir);
+    // 阻止系统休眠（macOS caffeinate / Windows SetThreadExecutionState）：lark-remote
+    // 的场景是人不在电脑前远程使用，系统休眠即失联。恒开启、无配置开关；helper 进程
+    // 绑定本进程生命周期（caffeinate -w / powershell 轮询父 pid），崩溃也能自清理；
+    // 'exit' 钩子里的 stop() 仅覆盖优雅退出路径。
+    const sleepBlocker = startSleepBlocker({ platform: currentPlatform, pid: process.pid });
+    if (sleepBlocker) {
+        process.on('exit', () => sleepBlocker.stop());
+    }
     logger.info('config loaded');
     logger.info(`configDir = ${configDir}`);
     logger.info(`feishu.appId = ${config.feishu.appId}`);
@@ -741,7 +751,7 @@ async function main() {
             }
         }
     }
-    logger.info('bridge is running, press Ctrl+C to exit');
+    logger.info('lark-remote is running, press Ctrl+C to exit');
 }
 main().catch((err) => {
     getLogger().error('fatal error:', err);

package/dist/platform/command.js

@@ -46,7 +46,7 @@ function isBashQuery(name) {
     return lower === 'bash' || lower === 'bash.exe';
 }
 /**
- * 缓存 TTL：probe 层（runner/probe.ts）5 分钟，本层更短——bridge 运行期间
+ * 缓存 TTL：probe 层（runner/probe.ts）5 分钟，本层更短——lark-remote 运行期间
  * 用户新装/卸载 agent（典型场景：按 /config 不可用提示去安装）后，最迟
  * TTL 过期即可被重新探测到，不必重启。null（未找到）结果同样过期重查。
  */

package/dist/platform/sleep-blocker.d.ts

@@ -0,0 +1,17 @@
+import { spawnProcess } from './spawn.js';
+export interface SleepBlocker {
+    /** 防御性停止 helper（正常路径 helper 随 lark-remote 死亡自行退出）。 */
+    stop(): void;
+}
+export interface SleepBlockerOptions {
+    platform: NodeJS.Platform;
+    pid: number;
+    /** 测试注入点：默认走 platform/spawn.ts 的 cross-spawn 收口。 */
+    spawnFn?: typeof spawnProcess;
+}
+/**
+ * PowerShell 托管脚本：声明 P/Invoke → 设置持续唤醒 → 轮询父 pid 直至父进程消失。
+ * 单字符串经 `-Command` 传入（不经 shell，内嵌双引号安全）；父 pid 是 number，插值安全。
+ */
+export declare function win32SleepBlockerScript(parentPid: number): string;
+export declare function startSleepBlocker(opts: SleepBlockerOptions): SleepBlocker | null;

package/dist/platform/sleep-blocker.js

@@ -0,0 +1,73 @@
+import { spawnProcess } from './spawn.js';
+import { getLogger } from '../logger/index.js';
+/** ES_CONTINUOUS (0x80000000) | ES_SYSTEM_REQUIRED (0x00000001)。 */
+const ES_FLAGS = '0x80000001';
+/**
+ * PowerShell 托管脚本：声明 P/Invoke → 设置持续唤醒 → 轮询父 pid 直至父进程消失。
+ * 单字符串经 `-Command` 传入（不经 shell，内嵌双引号安全）；父 pid 是 number，插值安全。
+ */
+export function win32SleepBlockerScript(parentPid) {
+    return [
+        `Add-Type -TypeDefinition 'using System.Runtime.InteropServices; public static class SleepBlocker { [DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags); }'`,
+        `[SleepBlocker]::SetThreadExecutionState(${ES_FLAGS}) | Out-Null`,
+        `while (Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue) { Start-Sleep -Seconds 30 }`,
+    ].join('; ');
+}
+export function startSleepBlocker(opts) {
+    const { platform, pid } = opts;
+    const spawnFn = opts.spawnFn ?? spawnProcess;
+    const logger = getLogger();
+    let command;
+    let args;
+    if (platform === 'darwin') {
+        command = 'caffeinate';
+        args = ['-i', '-w', String(pid)];
+    }
+    else if (platform === 'win32') {
+        command = 'powershell.exe';
+        args = ['-NoProfile', '-NonInteractive', '-Command', win32SleepBlockerScript(pid)];
+    }
+    else {
+        return null;
+    }
+    let proc;
+    try {
+        proc = spawnFn(command, args, { stdio: 'ignore' });
+    }
+    catch (err) {
+        logger.warn(`[sleep-blocker] failed to spawn ${command}:`, err);
+        return null;
+    }
+    // spawn 二进制缺失早检 + error 事件兜底（同 runner 层纪律）
+    if (proc.pid === undefined) {
+        logger.warn(`[sleep-blocker] ${command} unavailable (spawn failed), sleep prevention off`);
+        return null;
+    }
+    proc.on('error', (err) => {
+        logger.warn(`[sleep-blocker] ${command} error:`, err);
+    });
+    // helper 意外死亡 = 防休眠静默失效（win32 上 Add-Type 动态编译被企业策略/
+    // 杀软拦掉、Get-Process 权限失败；darwin 上 caffeinate 早退）。桥此时还活着，
+    // 是唯一能留痕的时机——否则日志里只剩启动那句 "active"，误以为防休眠在生效。
+    let stopping = false;
+    proc.on('exit', (code, signal) => {
+        if (stopping)
+            return;
+        logger.warn(`[sleep-blocker] ${command} exited unexpectedly (code=${code}, signal=${signal}), sleep prevention off`);
+    });
+    // helper 不得阻止 lark-remote 自身退出；父进程死后 helper 走各自的自清理机制退出
+    proc.unref();
+    logger.info(`[sleep-blocker] active via ${command} pid=${proc.pid}`);
+    return {
+        stop() {
+            stopping = true;
+            try {
+                proc.kill();
+            }
+            catch {
+                // helper 已死或不可杀——正常路径下它会自行退出，忽略
+            }
+        },
+    };
+}
+//# sourceMappingURL=sleep-blocker.js.map

package/dist/platform/terminator-win32.js

@@ -100,7 +100,7 @@ export function createWin32Terminator(deps) {
             // M0 真机验证项（§9.2 矩阵）：本方法在 process.on('exit') 里调用，而
             // killTree 依赖 libuv uv_spawn 在 exit handler 内同步发起 taskkill——
             // 大概率可用（uv_spawn 本身同步），但与 posix 路径（同步 process.kill）
-            // 可靠性不等价；失败表现为 win32 上 bridge 退出后 agent 变孤儿。
+            // 可靠性不等价；失败表现为 win32 上 lark-remote 退出后 agent 变孤儿。
             if (!isAlive(proc))
                 return;
             killTree(proc.pid);

package/dist/restart.d.ts

@@ -1,6 +1,6 @@
 /**
  * Self-restart without an external watchdog/cron: the only process that can
- * reliably start the successor is the dying bridge itself. The old process
+ * reliably start the successor is the dying lark-remote itself. The old process
  * spawns a detached replacement (same executable + argv, hence same
  * --config-dir), then exits cleanly. The child learns the old pid via env
  * and waits for it to die before acquiring the instance lock, so the lock
@@ -9,7 +9,7 @@
 /** Env var telling a replacement child which parent pid to wait for before acquiring the instance lock. */
 export declare const RESTART_WAIT_PID_ENV = "LARK_REMOTE_RESTART_WAIT_PID";
 /**
- * Spawn a detached bridge process (shared by /restart replacement and /clone
+ * Spawn a detached lark-remote process (shared by /restart replacement and /clone
  * new-instance) whose early output — before the child's own file logger
  * initializes — lands on logFilePath. Returns the child pid, or null when
  * spawn failed synchronously / no pid; filesystem errors (unwritable log
@@ -26,7 +26,7 @@ export declare function spawnDetachedBridge(args: string[], logFilePath: string,
     env?: NodeJS.ProcessEnv;
 }): number | null;
 /**
- * Spawn a detached replacement bridge with the same executable and argv
+ * Spawn a detached replacement lark-remote with the same executable and argv
  * (including --config-dir) and return its pid. The caller is expected to
  * exit right after. stdio is redirected to restart-child.log so early
  * startup failures (before the file logger initializes) are not lost.
@@ -34,7 +34,7 @@ export declare function spawnDetachedBridge(args: string[], logFilePath: string,
 export declare function spawnReplacementBridge(logsDir: string): number;
 /**
  * On startup, if this process was spawned as a restart replacement, wait for
- * the previous bridge process to exit (and release the instance lock) before
+ * the previous lark-remote process to exit (and release the instance lock) before
  * continuing. No-op for normal starts. On timeout, proceed anyway — lock
  * acquisition remains the authority.
  */

package/dist/restart.js

@@ -5,7 +5,7 @@ import { getLogger } from './logger/index.js';
 import { sleep } from './common/sleep.js';
 /**
  * Self-restart without an external watchdog/cron: the only process that can
- * reliably start the successor is the dying bridge itself. The old process
+ * reliably start the successor is the dying lark-remote itself. The old process
  * spawns a detached replacement (same executable + argv, hence same
  * --config-dir), then exits cleanly. The child learns the old pid via env
  * and waits for it to die before acquiring the instance lock, so the lock
@@ -16,7 +16,7 @@ export const RESTART_WAIT_PID_ENV = 'LARK_REMOTE_RESTART_WAIT_PID';
 const WAIT_TIMEOUT_MS = 20_000;
 const POLL_MS = 100;
 /**
- * Spawn a detached bridge process (shared by /restart replacement and /clone
+ * Spawn a detached lark-remote process (shared by /restart replacement and /clone
  * new-instance) whose early output — before the child's own file logger
  * initializes — lands on logFilePath. Returns the child pid, or null when
  * spawn failed synchronously / no pid; filesystem errors (unwritable log
@@ -51,7 +51,7 @@ export function spawnDetachedBridge(args, logFilePath, opts) {
     }
 }
 /**
- * Spawn a detached replacement bridge with the same executable and argv
+ * Spawn a detached replacement lark-remote with the same executable and argv
  * (including --config-dir) and return its pid. The caller is expected to
  * exit right after. stdio is redirected to restart-child.log so early
  * startup failures (before the file logger initializes) are not lost.
@@ -61,13 +61,13 @@ export function spawnReplacementBridge(logsDir) {
         env: { ...process.env, [RESTART_WAIT_PID_ENV]: String(process.pid) },
     });
     if (pid === null) {
-        throw new Error('spawn replacement bridge failed: no pid');
+        throw new Error('spawn replacement lark-remote failed: no pid');
     }
     return pid;
 }
 /**
  * On startup, if this process was spawned as a restart replacement, wait for
- * the previous bridge process to exit (and release the instance lock) before
+ * the previous lark-remote process to exit (and release the instance lock) before
  * continuing. No-op for normal starts. On timeout, proceed anyway — lock
  * acquisition remains the authority.
  */

package/dist/router/config/kimi.js

@@ -7,9 +7,10 @@
 import { loadKimiConfig, KIMI_THINKING_EFFORTS, FALLBACK_EFFORTS, } from '../../config/kimi-config.js';
 import { DEFAULT_TURN_IDLE_TIMEOUT_MINUTES } from '../../config/index.js';
 const PERMISSION_MODE_OPTIONS = [
-    { text: 'manual（逐项审批）', value: 'manual' },
-    { text: 'auto（引擎裁决）', value: 'auto' },
-    { text: 'yolo（全部放行）', value: 'yolo' },
+    // kimi 0.40.0（2026-09-02）起官方语义：manual=始终询问 / yolo=必要时询问 / auto=完全自动
+    { text: 'manual（始终询问）', value: 'manual' },
+    { text: 'auto（完全自动）', value: 'auto' },
+    { text: 'yolo（必要时询问）', value: 'yolo' },
 ];
 export class KimiConfigBuilder {
     buildFields(displayConfig) {

package/dist/router/index.js

@@ -2030,8 +2030,8 @@ export class CommandRouter {
             { cmd: 'ws', label: '/ws', desc: 'workspace 管理（save|use|remove）' },
             { cmd: 'config', label: '/config /c', desc: '查看和修改配置（卡片交互）' },
             { cmd: 'active', label: '/active', desc: '查看所有正在进行中的 session' },
-            { cmd: 'exit', label: '/exit /e', desc: '退出 bridge' },
-            { cmd: 'restart', label: '/restart', desc: '重启 bridge（新进程，config 不变）' },
+            { cmd: 'exit', label: '/exit /e', desc: '退出 lark-remote' },
+            { cmd: 'restart', label: '/restart', desc: '重启 lark-remote（新进程，config 不变）' },
             { cmd: 'update', label: '/update /u', desc: '检查并升级到最新版本' },
             {
                 cmd: 'clone',
@@ -2140,6 +2140,16 @@ export class CommandRouter {
                 content: '**Agent**\n通过 `/config` → 默认 Agent 切换：Claude / Codex / Opencode / Pi / Kimi',
             },
         });
+        // 系统休眠说明
+        bodyElements.push({ tag: 'hr' });
+        bodyElements.push({
+            tag: 'div',
+            text: {
+                tag: 'lark_md',
+                content: '**系统休眠**\nlark-remote 运行期间会阻止系统自动休眠，以免远程连接不上，' +
+                    '不影响显示器睡眠',
+            },
+        });
         return {
             card: {
                 schema: '2.0',
@@ -2228,7 +2238,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
     async cmdExit() {
         // Signal handle() to invoke exitHandler after the reply is sent.
         this.pendingExit = true;
-        return { text: 'bridge 正在退出...' };
+        return { text: 'lark-remote 正在退出...' };
     }
     cmdRestart() {
         if (!this.restartSpawner) {
@@ -2240,7 +2250,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
             // 链路——spawn 失败则旧进程保持存活，不会两头落空。
             const pid = this.restartSpawner();
             this.pendingExit = true;
-            return { text: `♻️ bridge 重启中（新进程 pid ${pid}），启动通知稍后送达…` };
+            return { text: `♻️ lark-remote 重启中（新进程 pid ${pid}），启动通知稍后送达…` };
         }
         catch (err) {
             getLogger().error('[router] restart spawn failed:', err);
@@ -3413,8 +3423,8 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         return { card };
     }
     cmdActive(_args, _ctx, offset = 0) {
-        // List all active runs from bridge memory (not from file system scan)
-        // New semantics (2026-07-20): only shows runs started by THIS bridge process
+        // List all active runs from lark-remote memory (not from file system scan)
+        // New semantics (2026-07-20): only shows runs started by THIS lark-remote process
         const activeRuns = this.bridge.getActiveRuns();
         const activeBashRuns = this.bridge.getActiveBashRuns();
         if (activeRuns.length === 0 && activeBashRuns.length === 0) {

package/dist/runner/common/acp/base-acp-runner.js

@@ -1,4 +1,4 @@
-import { respondAcpApproval, sendAcpSetMode } from './protocol-helpers.js';
+import { respondAcpApproval, sendAcpSetMode, truncateWithEllipsis, } from './protocol-helpers.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../connection-based-runner.js';
 export class BaseAcpRunner extends ConnectionBasedRunner {
@@ -87,7 +87,12 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
                     options,
                     ...(proto ? { proto } : {}),
                 });
-                getLogger().info(`[${this.logTag}] approval requested requestId=${ev.requestId} kind=${ev.kind}`);
+                // 命令预览进日志：审批卡在飞书侧，日志是本地唯一的事后追溯通道
+                // （kimi 的 request_permission 不带 rawInput，曾只剩 kind=command 可查）。
+                const commandPreview = ev.view.command
+                    ? ` command=${truncateWithEllipsis(ev.view.command, 120)}`
+                    : '';
+                getLogger().info(`[${this.logTag}] approval requested requestId=${ev.requestId} kind=${ev.kind}${commandPreview}`);
             }
         }
     }

package/dist/runner/common/acp/base-translator.d.ts

@@ -59,6 +59,16 @@ export declare abstract class BaseAcpTranslator {
     protected liveCostUsd?: number;
     /** Current turn id, set by produceTurnStarted. */
     protected currentTurnId: string;
+    /**
+     * Latest streaming-args text per tool call (keyed by wire toolCallId).
+     * kimi ACP sends the permission request BEFORE tool.call.started (verified
+     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * carries only title + a truncated summary in content, NO rawInput — the
+     * full args only ever reach the client as accumulated text in the
+     * tool_call/tool_call_update streaming deltas. Tracking them here lets the
+     * approval handler correlate by toolCallId and recover the real command.
+     */
+    private toolCallArgsByCallId;
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -115,6 +125,15 @@ export declare abstract class BaseAcpTranslator {
      * tool_call_update → user/tool_result. status:'failed' → is_error:true.
      */
     protected handleToolCallUpdate(event: ToolCallUpdateEvent, _sessionId: string): AcpTranslatorEvent[];
+    /**
+     * Latest tracked streaming-args text for a tool call (undefined when never
+     * seen or already terminated). Approval handlers correlate
+     * request_permission's toolCall.toolCallId against this to recover the real
+     * command (see toolCallArgsByCallId).
+     */
+    protected getTrackedToolCallArgs(toolCallId: string): string | undefined;
+    /** Record latest args text, bounded so a long session cannot grow it forever. */
+    private trackToolCallArgs;
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT

package/dist/runner/common/acp/base-translator.js

@@ -11,6 +11,36 @@ const KIND_TO_TOOL = {
     search: 'Grep',
     fetch: 'WebFetch',
 };
+/**
+ * Join the text payloads of a tool_call(/_update) content array
+ * (`[{type:'content', content:{type:'text', text}}]` entries). Returns
+ * undefined when no text entry exists (diff/terminal-only content).
+ */
+function extractToolCallContentText(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    let text = '';
+    let found = false;
+    for (const entry of content) {
+        const e = entry;
+        if (e?.type === 'content' && e.content?.type === 'text' && typeof e.content.text === 'string') {
+            text += e.content.text;
+            found = true;
+        }
+    }
+    return found ? text : undefined;
+}
+/** Best-effort stringify for tracked rawInput objects (never throws). */
+function stringifyUnknown(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 // =============================================================================
 // Translator base class
 // =============================================================================
@@ -25,6 +55,16 @@ export class BaseAcpTranslator {
     liveCostUsd;
     /** Current turn id, set by produceTurnStarted. */
     currentTurnId = '';
+    /**
+     * Latest streaming-args text per tool call (keyed by wire toolCallId).
+     * kimi ACP sends the permission request BEFORE tool.call.started (verified
+     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * carries only title + a truncated summary in content, NO rawInput — the
+     * full args only ever reach the client as accumulated text in the
+     * tool_call/tool_call_update streaming deltas. Tracking them here lets the
+     * approval handler correlate by toolCallId and recover the real command.
+     */
+    toolCallArgsByCallId = new Map();
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -191,6 +231,13 @@ export class BaseAcpTranslator {
                 // Keep raw string as-is
             }
         }
+        const argsText = extractToolCallContentText(event.content);
+        if (argsText !== undefined) {
+            this.trackToolCallArgs(event.toolCallId, argsText);
+        }
+        else if (event.rawInput !== undefined && event.rawInput !== null) {
+            this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
+        }
         const mapped = event.kind ? KIND_TO_TOOL[event.kind] : undefined;
         const name = mapped ?? event.title;
         const summary = mapped && event.title && event.title !== name ? event.title : undefined;
@@ -218,6 +265,22 @@ export class BaseAcpTranslator {
     handleToolCallUpdate(event, _sessionId) {
         const isError = event.status === 'failed';
         const content = this.extractToolResultContent(event);
+        // Terminal updates end the args-streaming phase — drop the tracked entry.
+        // In-progress delta text is cumulative (events-map.ts
+        // toolCallDeltaToSessionUpdate: content.text = accumulator.args), so the
+        // latest text replaces the previous one rather than appending.
+        if (event.status === 'completed' || event.status === 'failed') {
+            this.toolCallArgsByCallId.delete(event.toolCallId);
+        }
+        else {
+            const argsText = extractToolCallContentText(event.content);
+            if (argsText !== undefined) {
+                this.trackToolCallArgs(event.toolCallId, argsText);
+            }
+            else if (event.rawInput !== undefined && event.rawInput !== null) {
+                this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
+            }
+        }
         return [
             {
                 type: 'user',
@@ -235,6 +298,25 @@ export class BaseAcpTranslator {
             },
         ];
     }
+    /**
+     * Latest tracked streaming-args text for a tool call (undefined when never
+     * seen or already terminated). Approval handlers correlate
+     * request_permission's toolCall.toolCallId against this to recover the real
+     * command (see toolCallArgsByCallId).
+     */
+    getTrackedToolCallArgs(toolCallId) {
+        return this.toolCallArgsByCallId.get(toolCallId);
+    }
+    /** Record latest args text, bounded so a long session cannot grow it forever. */
+    trackToolCallArgs(toolCallId, argsText) {
+        this.toolCallArgsByCallId.delete(toolCallId);
+        this.toolCallArgsByCallId.set(toolCallId, argsText);
+        if (this.toolCallArgsByCallId.size > 100) {
+            const oldest = this.toolCallArgsByCallId.keys().next().value;
+            if (oldest !== undefined)
+                this.toolCallArgsByCallId.delete(oldest);
+        }
+    }
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT