lark-remote 0.5.10 → 0.5.13

package/dist/index.js

@@ -5,18 +5,14 @@ import { parseCliArgs, resolveConfigDir, setConfigDir, printHelp, printVersion,
 import { FeishuConnector } from './connector/index.js';
 import { ClaudeRunner, CodexAppServerRunner, OpencodeAcpRunner, PiRpcRunner, KimiAcpRunner, DshRunner, } from './runner/index.js';
 import { AgentRegistry } from './runner/registry.js';
-import { AGENT_DISPLAY_NAMES, AGENT_KINDS } from './runner/types.js';
 import { probeAllAgents } from './runner/probe.js';
 import { warmCodexCatalogCache } from './config/codex-config.js';
 import { SessionReaderRegistry, SessionStore } from './session/index.js';
 import { ClaudeSessionReader, CodexSessionReader, OpencodeSessionReader, PiSessionReader, KimiSessionReader, DshSessionReader, } from './session/index.js';
-import { CommandRouter, isImmediateAction, DIRECT_RETURN_CMDS, SESSION_MUTATING_ACTION_CMDS, COMPACT_ACTION_CMDS, } from './router/index.js';
+import { CommandRouter } from './router/index.js';
 import { DshDaemon } from './runner/dsh/daemon.js';
 import { DshClient } from './runner/dsh/client.js';
 import { DshInflightStore, dshInflightPath, reconcileInflightDshRuns, } from './runner/dsh/inflight.js';
-import { dispatchOrderExecForQueue } from './router/order-exec-dispatch.js';
-import { buildCardActionFullValue } from './router/card-action-payload.js';
-import { actionFeedbackText } from './router/card-action-feedback.js';
 import { Bridge } from './bridge/index.js';
 import { initLogger, getLogger } from './logger/index.js';
 import { StartupContactStore, sendStartupHello } from './startup-contact.js';
@@ -29,22 +25,10 @@ import { startSleepBlocker } from './platform/sleep-blocker.js';
 import { checkLatestVersion, compareVersions, runInstallLatest, formatUpdateHint, } from './update/index.js';
 import { classifyRejection } from './error-classification.js';
 import { WorkspaceStore } from './workspace/index.js';
-import { InboundTurnAssembler } from './inbound/turn-assembler.js';
-import { InboundAuthorizer } from './inbound/authorize.js';
-import { stripPlaceholders } from './inbound/placeholder.js';
 import { buildSessionHistoryCard, pickResumeCardEvents } from './router/card-helpers.js';
 import { newSessionButton, resumeCompactButton, agentDisplayName } from './card/card-shared.js';
 import path from 'node:path';
-import fs from 'node:fs';
-import { bestEffortUnlink } from './common/fs.js';
-/**
- * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
- * 共用同一判定，防止将来加别名时两处漂移。
- */
-function isStopCommand(text) {
-    const t = text.trim().toLowerCase();
-    return t === '/stop' || t === '/t';
-}
+import { setupMessageHandlers } from './message-handlers.js';
 /** Send auto-resume card for a restored session */
 async function sendAutoResumeCard(connector, contact, cwd, session, state, compactSupported = false, stillRunning = false) {
     if (!contact.userId)
@@ -317,12 +301,6 @@ function initializeRunner(config, configDir, cliArgs) {
             getLogger().warn(`[dsh] startup probe failed: ${error.message}`);
         });
     }
-    // 显示名单源在 runner/types.ts 的 AGENT_DISPLAY_NAMES（启动注册与回退共用）
-    for (const kind of AGENT_KINDS) {
-        agentRegistry.registerDisplayName(kind, AGENT_DISPLAY_NAMES[kind]);
-    }
-    // 设置全局 registry，供 agentDisplayName 等全局函数使用
-    AgentRegistry.setGlobalInstance(agentRegistry);
     // Probe agent CLI availability (fire-and-forget, populates cache for /config card).
     // Don't block startup — log unavailable agents as warnings.
     probeAllAgents()
@@ -335,8 +313,8 @@ function initializeRunner(config, configDir, cliArgs) {
             getLogger().info('[probe] all agent CLIs available');
         }
     })
-        .catch(() => {
-        // Probe failure is non-fatal; /config card will retry on open.
+        .catch((err) => {
+        getLogger().warn(`[probe] background probe failed: ${err.message}`);
     });
     // Warm the codex model catalog in the background so the first Codex /config
     // card open reads a warm cache instead of blocking the event loop for up to
@@ -345,370 +323,6 @@ function initializeRunner(config, configDir, cliArgs) {
     warmCodexCatalogCache();
     return { agentRegistry, sessionReaderRegistry };
 }
-/** Setup message and card action handlers. */
-function setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession) {
-    // 入站统一装配器（2026-09-15）：图/文任意顺序 → 同一个 turn、同一个 prompt，
-    // 附件路径统一注入 prompt；无文本纯附件只回执（决策 2）。
-    const assembler = new InboundTurnAssembler({
-        onCommit: (turn, prompt) => {
-            // 入队时刻快照 cwd + agent/session 绑定，语义与旧路径一致
-            // （排队期间 /cd、/config 不再导致语义漂移）。
-            const messageId = turn.messageIds[turn.messageIds.length - 1] ?? '';
-            // turnMessageIds：终态收尾要覆盖本轮每一条消息（逐条挂的 Typing 得逐条撤）
-            const ctx = {
-                userId: turn.userId,
-                chatId: turn.chatId,
-                messageId,
-                turnMessageIds: turn.messageIds,
-            };
-            let cwd = sessionStore.getCwd(turn.userId) ?? '';
-            if (!cwd && workspaceStore) {
-                const workspaces = workspaceStore.list();
-                if (workspaces.length > 0)
-                    cwd = workspaces[0].path;
-            }
-            const binding = bridge.currentBinding(turn.userId);
-            bridge.enqueue(cwd, async () => {
-                // allowCommandPrefix: false —— prompt 已剥离占位符，绝不再做命令分发。
-                await router.handle(prompt, ctx, {
-                    cwdOverride: cwd,
-                    binding,
-                    allowCommandPrefix: false,
-                });
-            }, {
-                taskMeta: {
-                    userId: turn.userId,
-                    chatId: turn.chatId,
-                    messageId,
-                    messagePreview: prompt.slice(0, 3000),
-                    binding,
-                },
-            });
-        },
-        onReceipt: async (ctx, text) => {
-            await bridge.sendResult({ text }, ctx);
-        },
-    });
-    router.setInboundFlusher(() => assembler.flushAll('flush'));
-    // 统一的入站授权入口（文本 + 媒体共用）：未绑定时，首条入站消息——无论
-    // 纯文本、纯媒体还是图文混合——都完成 owner 绑定并触发一次 onboarding。
-    // 媒体入口原先只做只读 isOwner 检查，新安装用户第一条消息是截图时既不绑定、
-    // 也不保存、也没有任何反馈。
-    const authorizer = new InboundAuthorizer({
-        binder,
-        onBind: (userId, chatId) => {
-            // First-run onboarding: set default cwd + send welcome + Help card.
-            // setCwd is synchronous (before returning the async send promise) so the
-            // user's next message — which will hit the `owner` branch now that
-            // startup-contact.json has been written — finds cwd already set.
-            // process.cwd() is the only sensible default: the user started
-            // lark-remote in the directory they want to work in.
-            // setCwd only when no cwd is set yet (e.g. fresh start after bind).
-            // Don't overwrite an existing cwd — the user may have already set one
-            // via /cd or a previous bind. Use realpath for canonical form (matching
-            // Claude JSONL cwd, e.g. /tmp → /private/tmp on macOS).
-            let resolvedCwd;
-            try {
-                resolvedCwd = fs.realpathSync(process.cwd());
-            }
-            catch {
-                resolvedCwd = process.cwd();
-            }
-            if (!sessionStore.getCwd(userId)) {
-                sessionStore.setCwd(userId, resolvedCwd);
-            }
-            return (async () => {
-                try {
-                    // Message 1: bind confirmation + status (combined to avoid
-                    // Feishu out-of-order delivery across three separate messages).
-                    await connector.sendWithRetry(chatId, {
-                        text: `✅ 已绑定到本账号，此后仅你可使用本应用\n` +
-                            `📂 当前工作目录: \`${resolvedCwd}\`\n` +
-                            `🤖 默认 Agent: ${agentDisplayName(config.defaultAgent)}\n` +
-                            `💡 直接输入消息即可开始对话，或 /cd 切换目录`,
-                    });
-                    // Message 2: Help card.
-                    // Use router.cmdHelp() + manual send (without replyTo) so the Help
-                    // card appears as an independent message, not a reply to the PIN
-                    // message. router.handle('/help') would set replyTo=msg.messageId
-                    // (the PIN), causing the card to nest under the PIN in Feishu UI.
-                    const helpResult = router.cmdHelp();
-                    if (helpResult.card) {
-                        await connector.sendWithRetry(chatId, { card: helpResult.card });
-                    }
-                }
-                catch (err) {
-                    logger.error('[binder] onboarding send failed:', err);
-                }
-            })();
-        },
-    });
-    // 入站媒体（图片/文件/视频/语音/表情）：先认证后下载（修复）。
-    // connector 只上报"媒体到达"，这里先过 owner + enabled 闸门，通过后才
-    // 下载——未认证/关闭配置时不会发生任何网络下载或内存/磁盘占用。
-    // 下载是异步的：立刻把在途 promise 交给装配器（`kind: 'media'`），
-    // 保证「先图后文」不会先提交一个只含文本的 turn。
-    connector.setInboundMediaDetectedHandler((msg) => {
-        // 与文本入口共用授权：首条纯媒体也在这里完成 owner 绑定（bind_success
-        // 继续走下载 + 装配，纯媒体最终由装配器发 no-text 回执）。
-        const authorization = authorizer.authorize(msg.userId, msg.chatId);
-        if (authorization === 'rejected') {
-            logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
-            return;
-        }
-        // 读 router.config（活引用）：/config 保存后 setConfigValues 返回新对象，
-        // 启动时捕获的 config 参数会过期（修复）。
-        if (!router.config.inboundMedia.enabled) {
-            // 不静默：关闭时给 owner 明确反馈，避免发图后无任何反应。
-            // 不下载、不落盘，只进 rejected（随 turn 回执一起发出）。
-            assembler.ingest({
-                kind: 'rejected',
-                userId: msg.userId,
-                chatId: msg.chatId,
-                messageId: msg.messageId,
-                replyToMessageId: msg.replyToMessageId,
-                rawContentType: msg.rawContentType,
-                rejectedKind: 'file',
-                reason: '入站媒体保存已关闭（inboundMedia.enabled: false），未保存文件。' +
-                    '如需自动保存图片/文件，请开启后重试',
-            });
-            return;
-        }
-        const outcome = (async () => {
-            const payload = await connector.downloadInboundMedia(msg, {
-                maxFileSizeMb: router.config.inboundMedia.maxFileSizeMb,
-            });
-            try {
-                return await bridge.saveInboundMedia(payload);
-            }
-            catch (err) {
-                // save() 的正常路径会清理临时文件；这里兜底 save 进入 mkdir
-                // try 之前意外抛错的情况，避免 os.tmpdir 残留。
-                for (const item of payload.media) {
-                    bestEffortUnlink(item.tempPath);
-                }
-                throw err;
-            }
-        })();
-        assembler.ingest({
-            kind: 'media',
-            userId: msg.userId,
-            chatId: msg.chatId,
-            messageId: msg.messageId,
-            replyToMessageId: msg.replyToMessageId,
-            rawContentType: msg.rawContentType,
-            outcome,
-        });
-    });
-    connector.setMessageHandler((msg) => {
-        // 绑定/授权闸门：仅 owner 放行；非 owner 静默丢弃；未绑定时首条消息认领。
-        // 与媒体入口共用 InboundAuthorizer：bind_success 的 onboarding 只跑一次
-        // （同一条 post 同时带图和文字时两个入口都会看到 bind_success）。
-        const decision = authorizer.authorize(msg.userId, msg.chatId);
-        if (decision === 'rejected')
-            return;
-        // 首条消息只用于完成绑定，不转发给 agent（与旧行为一致）。
-        if (decision === 'bind_success')
-            return;
-        // decision === 'owner'：正常处理（不再每条覆盖 startup-contact）
-        logger.info(`message from ${msg.userId} (${msg.rawContentType}): ${msg.content.slice(0, 100)}`);
-        // 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);
-        if (isStopCommand(content)) {
-            void (async () => {
-                const interrupt = await bridge.interruptCurrentRunDetailed({
-                    userId: msg.userId,
-                    chatId: msg.chatId,
-                });
-                const ctx = { userId: msg.userId, chatId: msg.chatId, messageId: msg.messageId };
-                if (!interrupt.stopped) {
-                    await bridge.sendResult({ text: '当前没有运行中的进程' }, ctx);
-                }
-                else if ((interrupt.stoppedCount ?? 1) > 1) {
-                    // 并行 workspace 时 /stop 停全部，必须让用户看到数量。
-                    await bridge.sendResult({ text: `✅ 已停止 ${interrupt.stoppedCount} 个运行中的任务` }, ctx);
-                }
-            })().catch((err) => logger.error('[control] /stop failed:', err));
-            return;
-        }
-        // 先清洗，后判语义（§5.6）：结构占位符永远不能触发命令分发。
-        // `![image](img_v3_…)` 的首字符恰好是 `!` —— 2026-09-15 事故就是这么进 shell 的。
-        const stripped = stripPlaceholders(content);
-        if (stripped.unknownTags.length > 0) {
-            logger.warn(`[inbound] unknown placeholder tags stripped: ${stripped.unknownTags.join(', ')} ` +
-                `(msg_type=${msg.rawContentType})`);
-        }
-        const commandEligible = msg.rawContentType === 'text' && stripped.kinds.length === 0 && stripped.clean !== '';
-        // 命令消息旁路装配窗口：/命令 立即执行，但必须先等窗口内已装配的内容
-        // （含在途媒体下载）提交完成。此前 `void flush()` 不等待，
-        // 有下载在途时命令会先于 commit 执行——发送在 /cd、/new 前的消息被绑定到
-        // 新 cwd/session，媒体也落到新目录。/stop 已在上面走快速路径，不受影响。
-        if (commandEligible && (stripped.clean.startsWith('/') || stripped.clean.startsWith('!'))) {
-            void (async () => {
-                await assembler.flush(msg.userId, msg.chatId, 'flush');
-                await router.handle(stripped.clean, {
-                    userId: msg.userId,
-                    chatId: msg.chatId,
-                    messageId: msg.messageId,
-                }, { allowCommandPrefix: true });
-            })().catch((err) => logger.error('[control] command failed:', err));
-            return;
-        }
-        // 普通消息：进装配器，等静默期窗口到期（下载落定）后合并成一个 turn。
-        assembler.ingest({
-            kind: 'text',
-            userId: msg.userId,
-            chatId: msg.chatId,
-            messageId: msg.messageId,
-            replyToMessageId: msg.replyToMessageId,
-            rawContentType: msg.rawContentType,
-            text: stripped.clean,
-            placeholders: stripped.kinds,
-            unknownTags: stripped.unknownTags,
-        });
-    });
-    connector.setCardActionHandler(async (action) => {
-        // 仅已绑定的 owner 可触发卡片操作；其余静默丢弃（计数 + debug）
-        if (!binder.isOwner(action.operator.openId)) {
-            binder.recordRejectedCardAction(action.operator.openId);
-            return;
-        }
-        const actionValue = action.action.value;
-        if (!actionValue?.cmd)
-            return;
-        logger.info(`card action: ${actionValue.cmd}`);
-        const userId = action.operator.openId;
-        const chatId = action.chatId;
-        const messageId = action.messageId;
-        // Add Typing reaction to indicate "still alive"
-        void connector.addReaction(messageId, 'Typing');
-        if (actionValue.cmd === 'stop') {
-            if (!actionValue.runId) {
-                logger.warn('[control] ignored stop card action without runId');
-                // Card button clicks must have visible feedback (design constraint: card button
-                // 点击必须有可见反馈，见 design.md §6.2)。
-                void bridge
-                    .sendResult({ text: '⚠️ 无效的停止请求，缺少必要信息' }, { userId, chatId, messageId })
-                    .catch((err) => logger.error('[control] card stop feedback failed:', err));
-                return;
-            }
-            void (async () => {
-                const stopped = await bridge.interruptCurrentRun({
-                    userId,
-                    chatId,
-                    runId: actionValue.runId,
-                });
-                if (!stopped) {
-                    // runId mismatch or run already exited — mirror /stop text miss path.
-                    await bridge.sendResult({ text: '该任务已结束，无需终止' }, { userId, chatId, messageId });
-                }
-            })().catch((err) => logger.error('[control] card stop failed:', err));
-            return;
-        }
-        const isImmediate = isImmediateAction(actionValue.cmd);
-        const cwd = sessionStore.getCwd(userId) ?? '';
-        // Build full value object — spread all fields from actionValue, then merge
-        // component out-of-band fields (option/formValue/inputValue/options) where
-        // present. See card-action-payload.ts for the component-type contract.
-        const fullValue = buildCardActionFullValue(actionValue, action);
-        // 定序（2026-10-07）：会话 / cwd / agent 变更类卡片动作（new-session、
-        // resume.use、ls.switch、ws.use、config.save）执行前先冲刷入站装配窗口，
-        // 保证窗口内先到的文本消息在本动作之前 commit（绑定旧 session/cwd/agent）。
-        // 否则 700ms 静默窗内的消息会漂移到动作之后的新状态：例如输入「重新构建」
-        // 后立即点「新会话」，消息会落到新会话。名单以 router 单源为准。
-        if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
-            await assembler.flush(userId, chatId, 'flush');
-        }
-        // queue.input / config.save / approval.respond / approval.toggle /
-        // approval.answer 系列返回 CardActionResponse toast 给点击用户即时反馈。
-        // 必须直接返回值 -- enqueueImmediate / enqueueConfigAction 是
-        // fire-and-forget，会吞掉返回值（answer 家族曾漏在直返列表外，
-        // 过期/重复 nonce/非法选项等错误 toast 被静默吞掉）。
-        // 审批响应尤其不能落串行队列：run 任务占用队列头直到 turn 结束，审批响应
-        // 排在后面会形成死锁（run 不结束不执行、run 结束 coordinator 已删响应空转）。
-        // order.aliasInput / order.aliasRemove / order.textInput 也返回 toast+card，
-        // 需直返避免被吞（order.textInput 曾漏在列表外，编辑卡停留在编辑界面）。
-        // approval.planFeedback 同 answer 系列：附意见的 toast 需直返 + 不落串行队列。
-        // 直返名单以 router 的 DIRECT_RETURN_CMDS 为单一来源（历史注释：
-        // order.textInput 曾漏在列表外、answer 家族曾漏在直返列表外——两份拷贝漂移）。
-        if (DIRECT_RETURN_CMDS.has(actionValue.cmd)) {
-            return router.handleCardAction(fullValue, { userId, chatId, messageId });
-        }
-        // order.exec → equivalent queued message (Plan A): resolve the order text
-        // at the enqueue boundary and route it through router.handle, exactly like
-        // a hand-typed message. See order-exec-dispatch.ts for the contract and
-        // why an internal key replaces the Feishu card messageId.
-        // （order.aliasEdit 是控制动作，走 enqueueImmediate 弹卡即可，不需直返。）
-        if (actionValue.cmd === 'order.exec') {
-            void dispatchOrderExecForQueue({
-                router,
-                bridge,
-                cwd,
-                orderId: actionValue.orderId,
-                ctx: { userId, chatId, messageId },
-            }).catch((err) => logger.error('[control] order.exec dispatch failed:', err));
-            return;
-        }
-        // 非直返命令到这里已经没有回调响应可回（enqueue* 是 fire-and-forget），
-        // handler 返回的 toast 必须显式转成持久文本，否则失败毫无反馈。
-        const forwardActionFeedback = (res) => {
-            const text = actionFeedbackText(res);
-            if (!text)
-                return;
-            void bridge
-                .sendResult({ text }, { userId, chatId, messageId })
-                .catch((err) => logger.error('[control] card action feedback failed:', err));
-        };
-        if (isImmediate) {
-            bridge.enqueueImmediate(cwd, async () => {
-                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
-                forwardActionFeedback(res);
-            });
-        }
-        else {
-            bridge.enqueue(cwd, async () => {
-                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
-                forwardActionFeedback(res);
-            }, {
-                taskMeta: {
-                    userId,
-                    chatId,
-                    // 队列身份 key 必须与「这一次点击」1:1：同一张卡片可点 N 次
-                    // （Compact 尤其明显），复用卡片 messageId 会让同 key 的多条排队
-                    // 任务在 queuedTasks/taskIndex/queueCardMessages 三处 lookup 里互相
-                    // 顶替（2026-10-08 线上：连点 Compact 三次 → 三张卡都显示「第 1 位」、
-                    // 两张永久停在「等待中」，只压缩一次）。
-                    messageId: router.mintQueueTaskKey('card', actionValue.cmd),
-                    // 卡片 messageId 仍然要留着当回复目标：排队卡要回复到被点击的卡片，
-                    // 内部 key 不是合法飞书 id（replyTo 用它会 400）。
-                    feishuReplyTo: messageId,
-                    messagePreview: `card action: ${actionValue.cmd}`,
-                    // lane 占用者的展示类型：压缩类动作在排队卡上自报身份
-                    // （「正在执行: 🗜 Compact」），并据此禁用「立即执行」。
-                    kind: COMPACT_ACTION_CMDS.has(actionValue.cmd) ? 'compact' : 'command',
-                    // Compact 是单向操作，排队卡不允许编辑（编辑预览无意义）。
-                    editable: !COMPACT_ACTION_CMDS.has(actionValue.cmd),
-                },
-            });
-        }
-    });
-}
 async function main() {
     const cliArgs = parseCliArgs();
     // --help/--version must bypass config loading and singleton lock — it's a pure
@@ -808,7 +422,17 @@ async function main() {
         updateCachePath: path.join(configDir, 'update-cache.json'),
         cloneSession,
     });
-    setupMessageHandlers(connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession);
+    setupMessageHandlers({
+        connector,
+        router,
+        bridge,
+        sessionStore,
+        workspaceStore,
+        binder,
+        logger,
+        config,
+        cloneSession,
+    });
     try {
         await connector.connect();
     }

package/dist/instance-lock.d.ts

@@ -33,7 +33,15 @@ export declare class InstanceLock {
      * 与 CIM CommandLine 首 token 归一后必然一致（bun/node 垫片场景亦然）。
      */
     private lockContents;
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     private tryCreate;
     /**
      * 把夺来的活锁放回原位。优先 `link`（目标已存在会失败，不会覆盖更新的锁），

package/dist/instance-lock.js

@@ -177,22 +177,57 @@ export class InstanceLock {
     lockContents(pid) {
         return `${pid}\n${binaryName(process.execPath)}`;
     }
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     tryCreate() {
+        const tmp = `${this.lockPath}.new-${process.pid}-${randomBytes(6).toString('hex')}`;
         try {
-            const fd = fs.openSync(this.lockPath, 'wx');
+            const fd = fs.openSync(tmp, 'wx');
             try {
                 fs.writeSync(fd, this.lockContents(process.pid));
             }
             finally {
                 fs.closeSync(fd);
             }
-            return true;
+            try {
+                fs.linkSync(tmp, this.lockPath);
+                return true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'EEXIST')
+                    return false;
+                if (code === 'EPERM' || code === 'EOPNOTSUPP' || code === 'ENOSYS' || code === 'EXDEV') {
+                    // hardlink 不可用（网络/overlay FS）：退回 wx 直建。
+                    try {
+                        const direct = fs.openSync(this.lockPath, 'wx');
+                        try {
+                            fs.writeSync(direct, this.lockContents(process.pid));
+                        }
+                        finally {
+                            fs.closeSync(direct);
+                        }
+                        return true;
+                    }
+                    catch (err2) {
+                        if (err2.code === 'EEXIST')
+                            return false;
+                        throw err2;
+                    }
+                }
+                throw err;
+            }
         }
-        catch (err) {
-            if (err.code === 'EEXIST')
-                return false;
-            throw err;
+        finally {
+            // 成功 link 后 tmp 与 lockPath 同 inode：删 tmp 只去掉多余名字（nlink 2→1）。
+            bestEffortUnlink(tmp);
         }
     }
     /**

package/dist/message-handlers.d.ts

@@ -0,0 +1,26 @@
+import type { AppConfig } from './config/index.js';
+import { getLogger } from './logger/index.js';
+import type { Bridge } from './bridge/index.js';
+import type { FeishuConnector } from './connector/index.js';
+import type { CommandRouter } from './router/index.js';
+import type { SessionStore } from './session/index.js';
+import type { WorkspaceStore } from './workspace/index.js';
+import type { OwnerBinder } from './binder.js';
+import type { CloneSession } from './clone.js';
+/**
+ * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
+ * 共用同一判定，防止将来加别名时两处漂移。
+ */
+export declare function isStopCommand(text: string): boolean;
+export interface MessageHandlerDeps {
+    connector: FeishuConnector;
+    router: CommandRouter;
+    bridge: Bridge;
+    sessionStore: SessionStore;
+    workspaceStore: WorkspaceStore;
+    binder: OwnerBinder;
+    logger: ReturnType<typeof getLogger>;
+    config: AppConfig;
+    cloneSession: CloneSession;
+}
+export declare function setupMessageHandlers(deps: MessageHandlerDeps): void;