lark-remote 0.2.2 → 0.4.0

package/dist/index.js

@@ -15,9 +15,12 @@ import { buildCardActionFullValue } from './router/card-action-payload.js';
 import { Bridge } from './bridge/index.js';
 import { initLogger, getLogger } from './logger/index.js';
 import { StartupContactStore, sendStartupHello } from './startup-contact.js';
-import { OwnerBinder, formatPinGuidance } from './binder.js';
+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';
@@ -26,6 +29,14 @@ import { newSessionButton, resumeCompactButton, agentDisplayName } from './card/
 import path from 'node:path';
 import fs from 'node:fs';
 import { silentlyUnlink } from './common/fs.js';
+/**
+ * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
+ * 共用同一判定，防止将来加别名时两处漂移。
+ */
+function isStopCommand(text) {
+    const t = text.trim().toLowerCase();
+    return t === '/stop' || t === '/t';
+}
 /** Send auto-resume card for a restored session */
 async function sendAutoResumeCard(connector, contact, cwd, session, state, compactSupported = false) {
     if (!contact.userId)
@@ -280,7 +291,7 @@ function initializeRunner(config, configDir, cliArgs) {
     return { agentRegistry, sessionReaderRegistry };
 }
 /** Setup message and card action handlers. */
-function setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config) {
+function setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession) {
     // 入站媒体（图片/文件）：先认证后下载（P1 review 修复）。
     // connector 只上报"媒体到达"，这里先过 owner + enabled 闸门，通过后才
     // 下载——未认证/关闭配置时不会发生任何网络下载或内存/磁盘占用。
@@ -324,13 +335,10 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         })().catch((err) => logger.error('[media] inbound media download/save failed:', err));
     });
     connector.setMessageHandler((msg) => {
-        // 绑定/授权闸门：仅 owner 放行；非 owner 静默丢弃；未绑定时要求 PIN 认领
+        // 绑定/授权闸门：仅 owner 放行；非 owner 静默丢弃；未绑定时首条消息（任意内容）认领
         const decision = binder.classify(msg.userId, msg.content, msg.chatId);
         if (decision.kind === 'rejected')
             return;
-        // 未绑定且 PIN 错误：完全静默丢弃（不回复、不提醒）
-        if (decision.kind === 'pin_wrong')
-            return;
         if (decision.kind === 'bind_success') {
             // First-run onboarding: set default cwd + send welcome + Help card.
             // setCwd is synchronous (outside the async closure) so that the user's
@@ -385,12 +393,23 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         bridge.flushMediaNotifications(msg.userId, msg.chatId);
         // Add Typing reaction to indicate "still alive"
         void connector.addReaction(msg.messageId, 'Typing');
+        // 复制分身流程活跃期：一切消息先经 clone 状态机（stop 命令除外，保留其
+        // 绕队列停止能力），不转发 coding agent、不进命令分发、不展开别名。
+        if (cloneSession.isActive() && !isStopCommand(msg.content)) {
+            void cloneSession
+                .handleMessage(msg.content, {
+                userId: msg.userId,
+                chatId: msg.chatId,
+                messageId: msg.messageId,
+            })
+                .catch((err) => logger.error('[clone] message handling failed:', err));
+            return;
+        }
         // 别名展开：命令分发前对消息做一次 $name 展开（不递归）。
         // `!` / `/` 开头的消息不会进入展开路径（$PATH、$HOME 等 shell 变量不受影响），
         // 未知 $xxx 原样透传；展开结果若以 `/` 开头会自然落入命令路径。
         const content = router.expandAliasMessage(msg.content);
-        const trimmedLower = content.trim().toLowerCase();
-        if (trimmedLower === '/stop' || trimmedLower === '/t') {
+        if (isStopCommand(content)) {
             void (async () => {
                 const stopped = await bridge.interruptCurrentRun({
                     userId: msg.userId,
@@ -605,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}`);
@@ -619,10 +646,10 @@ async function main() {
     const connector = new FeishuConnector(config);
     const startupContactStore = new StartupContactStore(path.join(configDir, 'startup-contact.json'));
     const binder = new OwnerBinder(startupContactStore);
-    if (binder.pendingPin) {
-        // 未绑定：控制台（stderr）展示 PIN。守护模式下被 watchdog 重定向到 daemon 日志
-        console.error(formatPinGuidance(binder.pendingPin));
-        logger.info('[binder] awaiting first binding (PIN printed to stderr)');
+    if (!binder.isBound()) {
+        // 未绑定：控制台（stderr）引导任意消息绑定。守护模式下被 watchdog 重定向到日志
+        console.error(formatBindGuidance());
+        logger.info('[binder] awaiting first binding (any first private message binds)');
     }
     else {
         logger.info(`[binder] bound to owner openId=${binder.boundOpenId()}`);
@@ -637,6 +664,11 @@ async function main() {
         agentRegistry,
         sessionReaderRegistry,
     });
+    const cloneSession = new CloneSession({
+        connector,
+        configPath: path.join(configDir, 'config.yaml'),
+        configDir,
+    });
     const router = new CommandRouter({
         sessionStore,
         bridge,
@@ -648,8 +680,9 @@ async function main() {
         sessionReaderRegistry,
         devMode: cliArgs.dev,
         updateCachePath: path.join(configDir, 'update-cache.json'),
+        cloneSession,
     });
-    setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config);
+    setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession);
     try {
         await connector.connect();
     }
@@ -718,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,24 @@
 /** 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 replacement bridge with the same executable and argv
+ * 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
+ * dir) propagate. Caller picks throw-vs-degrade semantics.
+ *
+ * Two disciplines live here so every caller inherits them for free:
+ * - windowsHide: win32 detached children would flash a console window (§3.7);
+ * - the 'error' handler is attached BEFORE the pid check — a failed spawn
+ *   emits 'error' asynchronously (ENOENT/EACCES), and the synchronous pid
+ *   check throws/returns first, so attaching after would leave the 'error'
+ *   event unhandled → uncaughtException kills the parent.
+ */
+export declare function spawnDetachedBridge(args: string[], logFilePath: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+}): number | null;
+/**
+ * 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.
@@ -17,7 +34,7 @@ export declare const RESTART_WAIT_PID_ENV = "LARK_REMOTE_RESTART_WAIT_PID";
 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,39 +16,58 @@ export const RESTART_WAIT_PID_ENV = 'LARK_REMOTE_RESTART_WAIT_PID';
 const WAIT_TIMEOUT_MS = 20_000;
 const POLL_MS = 100;
 /**
- * Spawn a detached replacement bridge with the same executable and argv
+ * 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
+ * dir) propagate. Caller picks throw-vs-degrade semantics.
+ *
+ * Two disciplines live here so every caller inherits them for free:
+ * - windowsHide: win32 detached children would flash a console window (§3.7);
+ * - the 'error' handler is attached BEFORE the pid check — a failed spawn
+ *   emits 'error' asynchronously (ENOENT/EACCES), and the synchronous pid
+ *   check throws/returns first, so attaching after would leave the 'error'
+ *   event unhandled → uncaughtException kills the parent.
+ */
+export function spawnDetachedBridge(args, logFilePath, opts) {
+    fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
+    const out = fs.openSync(logFilePath, 'a');
+    try {
+        const child = spawnProcess(process.execPath, args, {
+            cwd: process.cwd(),
+            env: opts?.env ?? process.env,
+            detached: true,
+            windowsHide: true,
+            stdio: ['ignore', out, out],
+        });
+        child.on('error', () => { });
+        if (child.pid === undefined)
+            return null;
+        child.unref();
+        return child.pid;
+    }
+    finally {
+        fs.closeSync(out);
+    }
+}
+/**
+ * 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.
  */
 export function spawnReplacementBridge(logsDir) {
-    fs.mkdirSync(logsDir, { recursive: true });
-    const out = fs.openSync(path.join(logsDir, 'restart-child.log'), 'a');
-    const child = spawnProcess(process.execPath, process.argv.slice(1), {
-        cwd: process.cwd(),
+    const pid = spawnDetachedBridge(process.argv.slice(1), path.join(logsDir, 'restart-child.log'), {
         env: { ...process.env, [RESTART_WAIT_PID_ENV]: String(process.pid) },
-        detached: true,
-        // win32：detached 继任者默认会闪控制台窗口（§3.7）
-        windowsHide: true,
-        stdio: ['ignore', out, out],
     });
-    // Late spawn errors (e.g. binary removed mid-run) must not crash the
-    // exiting parent via an unhandled 'error' event. Attach BEFORE the pid
-    // check — a failed spawn emits 'error' asynchronously (ENOENT/EACCES),
-    // and the pid check below throws synchronously first, so attaching after
-    // the throw would leave the 'error' event unhandled → uncaughtException
-    // → the old bridge exits despite having promised to stay alive.
-    child.on('error', () => { });
-    fs.closeSync(out);
-    if (child.pid === undefined) {
-        throw new Error('spawn replacement bridge failed: no pid');
+    if (pid === null) {
+        throw new Error('spawn replacement lark-remote failed: no pid');
     }
-    child.unref();
-    return child.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.d.ts

@@ -2,6 +2,7 @@ import type { SessionStore, SessionReaderRegistry } from '../session/index.js';
 import type { AppConfig } from '../config/index.js';
 import type { Bridge } from '../bridge/index.js';
 import type { AgentBinding } from '../bridge/queue-manager.js';
+import type { CloneSession } from '../clone.js';
 import { type VersionCheckResult, type InstallResult } from '../update/index.js';
 interface CommandContext {
     userId: string;
@@ -125,6 +126,8 @@ export declare class CommandRouter {
     private devMode;
     /** Cache file for version checks (<configDir>/update-cache.json). */
     private updateCachePath?;
+    /** 复制分身状态机（/clone 入口 + 活跃期消息拦截）。 */
+    private cloneSession?;
     /** Injected update functions (for testability; defaults to real implementation). */
     private updateFns;
     /** /config 卡片编辑暂存区（public：测试直接读取断言，替代 as unknown as）。 */
@@ -177,6 +180,8 @@ export declare class CommandRouter {
         devMode?: boolean;
         /** Version check cache path (<configDir>/update-cache.json). */
         updateCachePath?: string;
+        /** 复制分身状态机（/clone；index.ts 构造注入，未注入时命令回报不可用）。 */
+        cloneSession?: CloneSession;
         /** Override update functions for testability. */
         updateFns?: {
             checkLatestVersion?: (opts?: {
@@ -455,6 +460,11 @@ export declare class CommandRouter {
      * Flow: check version → if newer, install → report success (no auto-restart).
      */
     private cmdUpdate;
+    /**
+     * /clone [name] — 复制分身：进入 clone 状态机（发二维码、等扫码、自动绑定）。
+     * 全程由 CloneSession 自己经 connector 发消息（含二维码图片），故返回 null。
+     */
+    private cmdClone;
     private cmdNew;
     private cmdCd;
     private readSessionDisplayState;

package/dist/router/index.js

@@ -347,6 +347,8 @@ export class CommandRouter {
     devMode;
     /** Cache file for version checks (<configDir>/update-cache.json). */
     updateCachePath;
+    /** 复制分身状态机（/clone 入口 + 活跃期消息拦截）。 */
+    cloneSession;
     /** Injected update functions (for testability; defaults to real implementation). */
     updateFns;
     /** /config 卡片编辑暂存区（public：测试直接读取断言，替代 as unknown as）。 */
@@ -400,6 +402,7 @@ export class CommandRouter {
         this.sessionReaderRegistry = opts.sessionReaderRegistry;
         this.devMode = opts.devMode ?? false;
         this.updateCachePath = opts.updateCachePath;
+        this.cloneSession = opts.cloneSession;
         this.updateFns = {
             checkLatestVersion: opts.updateFns?.checkLatestVersion ?? defaultCheckLatestVersion,
             isNewer: opts.updateFns?.isNewer ?? defaultIsNewer,
@@ -421,6 +424,13 @@ export class CommandRouter {
         const startsWithBang = trimmed.startsWith('!');
         const startsWithSlash = trimmed.startsWith('/');
         getLogger().info(`[router] handle message="${message.slice(0, 50)}..." trimmed="${trimmed.slice(0, 50)}..." startsWithSlash=${startsWithSlash} startsWithBang=${startsWithBang}`);
+        // 复制分身流程活跃期：一切消息（含命令）交给 clone 状态机处理，
+        // 不转发 coding agent、不进命令分发（index.ts 已在入队前拦截，这里
+        // 兜住 order.exec 等其他 router.handle 入口）。
+        if (this.cloneSession?.isActive()) {
+            await this.cloneSession.handleMessage(trimmed, ctx);
+            return null;
+        }
         if (startsWithSlash) {
             const result = await this.executeCommand(trimmed, ctx);
             if (result) {
@@ -2001,6 +2011,8 @@ export class CommandRouter {
             case 'update':
             case 'u':
                 return await this.cmdUpdate(args, ctx);
+            case 'clone':
+                return await this.cmdClone(args, ctx);
             default:
                 return { text: `未知命令 /${cmd}，输入 /help 查看可用命令` };
         }
@@ -2018,9 +2030,14 @@ 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',
+                label: '/clone',
+                desc: '复制分身：克隆配置并扫码创建新应用',
+            },
             { cmd: 'status', label: '/status /s', desc: '显示当前状态' },
         ].sort((a, b) => a.label.length - b.label.length || a.cmd.localeCompare(b.cmd));
         // 文本组（需带参数，不宜用按钮；以纯文本行展示）
@@ -2123,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',
@@ -2211,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) {
@@ -2223,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);
@@ -2271,6 +2298,17 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         // 4. Report success (no auto-restart — user decides when to /restart)
         return { text: `✅ 升级成功 (${current} → ${latest})，发送 /restart 重启后生效` };
     }
+    /**
+     * /clone [name] — 复制分身：进入 clone 状态机（发二维码、等扫码、自动绑定）。
+     * 全程由 CloneSession 自己经 connector 发消息（含二维码图片），故返回 null。
+     */
+    async cmdClone(args, ctx) {
+        if (!this.cloneSession) {
+            return { text: '当前环境未启用创建分身功能' };
+        }
+        await this.cloneSession.start(args[0], ctx);
+        return null;
+    }
     cmdNew(ctx) {
         // 只清 sessionId 保留 cwd — 否则 /new 之后 /resume 会提示"请先 /cd
         // 设置工作目录"，但用户的 workspace 还在。2026-06-21 复盘：用户
@@ -3385,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