lark-remote 0.5.19 → 0.5.21

package/dist/logger/index.js

@@ -21,12 +21,12 @@ function todayStr(d) {
     return `${y}-${m}-${day}`;
 }
 function timestampStr(d) {
-    // local ISO 8601 with milliseconds and explicit offset, e.g.
-    // 2026-08-03T01:30:00.000+08:00. Previously this used toISOString() (UTC)
-    // while the daily directory boundary (todayStr) used local time — after
-    // local midnight in a +08:00 zone the new day's directory held lines
-    // timestamped with the previous UTC day. Local offset keeps the timestamp's
-    // calendar date consistent with the directory date across all timezones.
+    // Local ISO 8601 with milliseconds and explicit offset, e.g.
+    // 2026-08-03T01:30:00.000+08:00. Must match the daily directory boundary
+    // (todayStr), which is local time: a UTC timestamp would put lines written
+    // after local midnight into the previous UTC day's file. Local offset keeps
+    // the timestamp's calendar date consistent with the directory date across
+    // all timezones.
     const pad = (n) => String(n).padStart(2, '0');
     const y = d.getFullYear();
     const mo = pad(d.getMonth() + 1);

package/dist/message-handlers.d.ts

@@ -7,11 +7,6 @@ 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;

package/dist/message-handlers.js

@@ -14,264 +14,281 @@ const SESSION_MUTATING_FLUSH_BUDGET_MS = 2_000;
  * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
  * 共用同一判定，防止将来加别名时两处漂移。
  */
-export function isStopCommand(text) {
+function isStopCommand(text) {
     const t = text.trim().toLowerCase();
     return t === '/stop' || t === '/t';
 }
-export function setupMessageHandlers(deps) {
-    const { connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession, } = deps;
-    // 入站统一装配器：图/文任意顺序 → 同一个 turn、同一个 prompt。
-    const assembler = new InboundTurnAssembler({
-        onCommit: (turn, prompt) => {
-            const messageId = turn.messageIds[turn.messageIds.length - 1] ?? '';
-            const ctx = {
-                userId: turn.userId,
-                chatId: turn.chatId,
-                messageId,
-                turnMessageIds: turn.messageIds,
-            };
-            let cwd = sessionStore.getCwd(turn.userId) ?? '';
-            if (!cwd) {
-                const recent = [...workspaceStore.list()].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
-                if (recent.length > 0)
-                    cwd = recent[0].path;
-            }
-            const binding = bridge.currentBinding(turn.userId);
-            bridge.enqueue(cwd, async () => {
-                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);
+/** 入站统一装配器 commit：图/文组装成 turn → 进 agent 队列。 */
+function handleTurnCommit(ctx, turn, prompt) {
+    const messageId = turn.messageIds[turn.messageIds.length - 1] ?? '';
+    const taskCtx = {
+        userId: turn.userId,
+        chatId: turn.chatId,
+        messageId,
+        turnMessageIds: turn.messageIds,
+    };
+    let cwd = ctx.sessionStore.getCwd(turn.userId) ?? '';
+    if (!cwd) {
+        const recent = [...ctx.workspaceStore.list()].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+        if (recent.length > 0)
+            cwd = recent[0].path;
+    }
+    const binding = ctx.bridge.currentBinding(turn.userId);
+    ctx.bridge.enqueue(cwd, async () => {
+        await ctx.router.handle(prompt, taskCtx, {
+            cwdOverride: cwd,
+            binding,
+            allowCommandPrefix: false,
+        });
+    }, {
+        taskMeta: {
+            userId: turn.userId,
+            chatId: turn.chatId,
+            messageId,
+            messagePreview: prompt.slice(0, 3000),
+            binding,
         },
     });
-    router.setInboundFlusher(() => assembler.flushAll('flush'));
-    const authorizer = new InboundAuthorizer({
-        binder,
-        onBind: (userId, chatId) => {
-            let resolvedCwd;
-            try {
-                resolvedCwd = fs.realpathSync(process.cwd());
-            }
-            catch {
-                resolvedCwd = process.cwd();
-            }
-            if (!sessionStore.getCwd(userId)) {
-                sessionStore.setCwd(userId, resolvedCwd);
+}
+/** 入站回执（无文本纯附件 / rejected 项）：面向用户的提示。 */
+async function handleTurnReceipt(ctx, receiptCtx, text) {
+    await ctx.bridge.sendResult({ text }, receiptCtx);
+}
+/** owner 绑定成功后的 onboarding 消息（fire-and-forget）。 */
+function handleBind(ctx, userId, chatId) {
+    let resolvedCwd;
+    try {
+        resolvedCwd = fs.realpathSync(process.cwd());
+    }
+    catch {
+        resolvedCwd = process.cwd();
+    }
+    if (!ctx.sessionStore.getCwd(userId)) {
+        ctx.sessionStore.setCwd(userId, resolvedCwd);
+    }
+    return (async () => {
+        try {
+            await ctx.connector.sendWithRetry(chatId, {
+                text: `✅ 已绑定到本账号，此后仅你可使用本应用\n` +
+                    `📂 当前工作目录: \`${resolvedCwd}\`\n` +
+                    `🤖 默认 Agent: ${agentDisplayName(ctx.config.defaultAgent)}\n` +
+                    `💡 直接输入消息即可开始对话，或 /cd 切换目录`,
+            });
+            const helpResult = ctx.router.cmdHelp();
+            if (helpResult.card) {
+                await ctx.connector.sendWithRetry(chatId, { card: helpResult.card });
             }
-            return (async () => {
-                try {
-                    await connector.sendWithRetry(chatId, {
-                        text: `✅ 已绑定到本账号，此后仅你可使用本应用\n` +
-                            `📂 当前工作目录: \`${resolvedCwd}\`\n` +
-                            `🤖 默认 Agent: ${agentDisplayName(config.defaultAgent)}\n` +
-                            `💡 直接输入消息即可开始对话，或 /cd 切换目录`,
-                    });
-                    const helpResult = router.cmdHelp();
-                    if (helpResult.card) {
-                        await connector.sendWithRetry(chatId, { card: helpResult.card });
-                    }
-                }
-                catch (err) {
-                    logger.error('[binder] onboarding send failed:', err);
-                }
-            })();
-        },
-    });
-    connector.setInboundMediaDetectedHandler((msg) => {
-        const authorization = authorizer.authorize(msg.userId, msg.chatId);
-        if (authorization === 'rejected') {
-            logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
-            return;
         }
-        if (cloneSession.isActive()) {
-            logger.info(`[media] dropped inbound media during clone session ${msg.messageId}`);
-            return;
+        catch (err) {
+            ctx.logger.error('[binder] onboarding send failed:', err);
         }
-        if (!router.config.inboundMedia.enabled) {
-            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) {
-                for (const item of payload.media)
-                    bestEffortUnlink(item.tempPath);
-                throw err;
-            }
-        })();
-        assembler.ingest({
-            kind: 'media',
+    })();
+}
+/** 入站媒体（image/file）检测：鉴权 → clone 拦截 → 落盘或 rejected 回执。 */
+function handleInboundMedia(ctx, msg) {
+    const authorization = ctx.authorizer.authorize(msg.userId, msg.chatId);
+    if (authorization === 'rejected') {
+        ctx.logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
+        return;
+    }
+    if (ctx.cloneSession.isActive()) {
+        ctx.logger.info(`[media] dropped inbound media during clone session ${msg.messageId}`);
+        return;
+    }
+    if (!ctx.router.config.inboundMedia.enabled) {
+        ctx.assembler.ingest({
+            kind: 'rejected',
             userId: msg.userId,
             chatId: msg.chatId,
             messageId: msg.messageId,
             replyToMessageId: msg.replyToMessageId,
             rawContentType: msg.rawContentType,
-            outcome,
+            rejectedKind: 'file',
+            reason: '入站媒体保存已关闭（inboundMedia.enabled: false），未保存文件。' +
+                '如需自动保存图片/文件，请开启后重试',
         });
-    });
-    connector.setMessageHandler((msg) => {
-        const decision = authorizer.authorize(msg.userId, msg.chatId);
-        if (decision === 'rejected' || decision === 'bind_success')
-            return;
-        logger.info(`message from ${msg.userId} (${msg.rawContentType}): ${msg.content.slice(0, 100)}`);
-        void connector.addReaction(msg.messageId, 'Typing');
-        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;
-        }
-        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) {
-                    await bridge.sendResult({ text: `✅ 已停止 ${interrupt.stoppedCount} 个运行中的任务` }, ctx);
-                }
-            })().catch((err) => logger.error('[control] /stop failed:', err));
-            return;
-        }
-        const stripped = stripPlaceholders(content);
-        if (stripped.unknownTags.length > 0) {
-            logger.warn(`[inbound] unknown placeholder tags stripped: ${stripped.unknownTags.join(', ')} ` +
-                `(msg_type=${msg.rawContentType})`);
+        return;
+    }
+    const outcome = (async () => {
+        const payload = await ctx.connector.downloadInboundMedia(msg, {
+            maxFileSizeMb: ctx.router.config.inboundMedia.maxFileSizeMb,
+        });
+        try {
+            return await ctx.bridge.saveInboundMedia(payload);
         }
-        const commandEligible = msg.rawContentType === 'text' && stripped.kinds.length === 0 && stripped.clean !== '';
-        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;
+        catch (err) {
+            for (const item of payload.media)
+                bestEffortUnlink(item.tempPath);
+            throw err;
         }
-        assembler.ingest({
-            kind: 'text',
+    })();
+    ctx.assembler.ingest({
+        kind: 'media',
+        userId: msg.userId,
+        chatId: msg.chatId,
+        messageId: msg.messageId,
+        replyToMessageId: msg.replyToMessageId,
+        rawContentType: msg.rawContentType,
+        outcome,
+    });
+}
+/** 普通入站消息：鉴权 → clone 拦截 → /stop → 命令前缀 → 装配器。 */
+function handleInboundMessage(ctx, msg) {
+    const decision = ctx.authorizer.authorize(msg.userId, msg.chatId);
+    if (decision === 'rejected' || decision === 'bind_success')
+        return;
+    ctx.logger.info(`message from ${msg.userId} (${msg.rawContentType}): ${msg.content.slice(0, 100)}`);
+    void ctx.connector.addReaction(msg.messageId, 'Typing');
+    if (ctx.cloneSession.isActive() && !isStopCommand(msg.content)) {
+        void ctx.cloneSession
+            .handleMessage(msg.content, {
             userId: msg.userId,
             chatId: msg.chatId,
             messageId: msg.messageId,
-            replyToMessageId: msg.replyToMessageId,
-            rawContentType: msg.rawContentType,
-            text: stripped.clean,
-            placeholders: stripped.kinds,
-            unknownTags: stripped.unknownTags,
-        });
+        })
+            .catch((err) => ctx.logger.error('[clone] message handling failed:', err));
+        return;
+    }
+    const content = ctx.router.expandAliasMessage(msg.content);
+    if (isStopCommand(content)) {
+        void (async () => {
+            const interrupt = await ctx.bridge.interruptCurrentRunDetailed({
+                userId: msg.userId,
+                chatId: msg.chatId,
+            });
+            const stopCtx = { userId: msg.userId, chatId: msg.chatId, messageId: msg.messageId };
+            if (!interrupt.stopped) {
+                await ctx.bridge.sendResult({ text: '当前没有运行中的进程' }, stopCtx);
+            }
+            else if ((interrupt.stoppedCount ?? 1) > 1) {
+                await ctx.bridge.sendResult({ text: `✅ 已停止 ${interrupt.stoppedCount} 个运行中的任务` }, stopCtx);
+            }
+        })().catch((err) => ctx.logger.error('[control] /stop failed:', err));
+        return;
+    }
+    const stripped = stripPlaceholders(content);
+    if (stripped.unknownTags.length > 0) {
+        ctx.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 !== '';
+    if (commandEligible && (stripped.clean.startsWith('/') || stripped.clean.startsWith('!'))) {
+        void (async () => {
+            await ctx.assembler.flush(msg.userId, msg.chatId, 'flush');
+            await ctx.router.handle(stripped.clean, {
+                userId: msg.userId,
+                chatId: msg.chatId,
+                messageId: msg.messageId,
+            }, { allowCommandPrefix: true });
+        })().catch((err) => ctx.logger.error('[control] command failed:', err));
+        return;
+    }
+    ctx.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) => {
-        if (!binder.isOwner(action.operator.openId)) {
-            binder.recordRejectedCardAction(action.operator.openId);
-            return;
-        }
-        const actionValue = action.action.value;
-        if (!actionValue?.cmd)
-            return;
-        logger.info(actionValue.cmd === 'stop'
-            ? `card action: stop runId=${actionValue.runId ?? '(none)'} messageId=${action.messageId}`
-            : `card action: ${actionValue.cmd}`);
-        const userId = action.operator.openId;
-        const chatId = action.chatId;
-        const messageId = action.messageId;
-        void connector.addReaction(messageId, 'Typing');
-        if (actionValue.cmd === 'stop') {
-            void router
-                .handleCardAction({ ...actionValue, cmd: 'stop' }, { userId, chatId, messageId })
-                .catch((err) => logger.error('[control] card stop failed:', err));
-            return;
-        }
-        const isImmediate = isImmediateAction(actionValue.cmd);
-        const cwd = sessionStore.getCwd(userId) ?? '';
-        const fullValue = buildCardActionFullValue(actionValue, action);
-        if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
-            const flushP = assembler
-                .flush(userId, chatId, 'flush')
-                .catch((err) => logger.error('[control] inbound flush failed:', err));
-            await Promise.race([flushP, sleep(SESSION_MUTATING_FLUSH_BUDGET_MS)]);
-        }
-        if (DIRECT_RETURN_CMDS.has(actionValue.cmd)) {
-            return router.handleCardAction(fullValue, { userId, chatId, messageId });
-        }
-        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));
+}
+/** 卡片动作：鉴权 → stop/直返/order.exec → immediate 或普通队列。 */
+async function handleCardAction(ctx, action) {
+    if (!ctx.binder.isOwner(action.operator.openId)) {
+        ctx.binder.recordRejectedCardAction(action.operator.openId);
+        return;
+    }
+    const actionValue = action.action.value;
+    if (!actionValue?.cmd)
+        return;
+    ctx.logger.info(actionValue.cmd === 'stop'
+        ? `card action: stop runId=${actionValue.runId ?? '(none)'} messageId=${action.messageId}`
+        : `card action: ${actionValue.cmd}`);
+    const userId = action.operator.openId;
+    const chatId = action.chatId;
+    const messageId = action.messageId;
+    void ctx.connector.addReaction(messageId, 'Typing');
+    if (actionValue.cmd === 'stop') {
+        void ctx.router
+            .handleCardAction({ ...actionValue, cmd: 'stop' }, { userId, chatId, messageId })
+            .catch((err) => ctx.logger.error('[control] card stop failed:', err));
+        return;
+    }
+    const isImmediate = isImmediateAction(actionValue.cmd);
+    const cwd = ctx.sessionStore.getCwd(userId) ?? '';
+    const fullValue = buildCardActionFullValue(actionValue, action);
+    if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
+        const flushP = ctx.assembler
+            .flush(userId, chatId, 'flush')
+            .catch((err) => ctx.logger.error('[control] inbound flush failed:', err));
+        await Promise.race([flushP, sleep(SESSION_MUTATING_FLUSH_BUDGET_MS)]);
+    }
+    if (DIRECT_RETURN_CMDS.has(actionValue.cmd)) {
+        return ctx.router.handleCardAction(fullValue, { userId, chatId, messageId });
+    }
+    if (actionValue.cmd === 'order.exec') {
+        void dispatchOrderExecForQueue({
+            router: ctx.router,
+            bridge: ctx.bridge,
+            cwd,
+            orderId: actionValue.orderId,
+            ctx: { userId, chatId, messageId },
+        }).catch((err) => ctx.logger.error('[control] order.exec dispatch failed:', err));
+        return;
+    }
+    const forwardActionFeedback = (res) => {
+        const text = actionFeedbackText(res);
+        if (!text)
             return;
-        }
-        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,
-                    messageId: router.mintQueueTaskKey('card', actionValue.cmd),
-                    feishuReplyTo: messageId,
-                    messagePreview: `card action: ${actionValue.cmd}`,
-                    kind: COMPACT_ACTION_CMDS.has(actionValue.cmd) ? 'compact' : 'command',
-                    editable: !COMPACT_ACTION_CMDS.has(actionValue.cmd),
-                },
-            });
-        }
+        void ctx.bridge
+            .sendResult({ text }, { userId, chatId, messageId })
+            .catch((err) => ctx.logger.error('[control] card action feedback failed:', err));
+    };
+    if (isImmediate) {
+        ctx.bridge.enqueueImmediate(cwd, async () => {
+            const res = await ctx.router.handleCardAction(fullValue, { userId, chatId, messageId });
+            forwardActionFeedback(res);
+        });
+    }
+    else {
+        ctx.bridge.enqueue(cwd, async () => {
+            const res = await ctx.router.handleCardAction(fullValue, { userId, chatId, messageId });
+            forwardActionFeedback(res);
+        }, {
+            taskMeta: {
+                userId,
+                chatId,
+                messageId: ctx.router.mintQueueTaskKey('card', actionValue.cmd),
+                feishuReplyTo: messageId,
+                messagePreview: `card action: ${actionValue.cmd}`,
+                kind: COMPACT_ACTION_CMDS.has(actionValue.cmd) ? 'compact' : 'command',
+                editable: !COMPACT_ACTION_CMDS.has(actionValue.cmd),
+            },
+        });
+    }
+}
+export function setupMessageHandlers(deps) {
+    // ctx 在 assembler/authorizer 创建后填充；转发箭头只在事件触发时读它。
+    // 所有决策逻辑都在模块级 handler 中，本函数只做注册，圈复杂度保持最低。
+    // 循环初始化：两个实例的回调捕获 ctx，而 ctx 又需要这两个实例，无法在
+    // 声明处一次性初始化；回调只在事件到达时执行，那时填充早已完成。
+    // eslint-disable-next-line prefer-const
+    let ctx;
+    const assembler = new InboundTurnAssembler({
+        onCommit: (turn, prompt) => handleTurnCommit(ctx, turn, prompt),
+        onReceipt: (receiptCtx, text) => handleTurnReceipt(ctx, receiptCtx, text),
+    });
+    deps.router.setInboundFlusher(() => assembler.flushAll('flush'));
+    const authorizer = new InboundAuthorizer({
+        binder: deps.binder,
+        onBind: (userId, chatId) => handleBind(ctx, userId, chatId),
     });
+    ctx = { ...deps, assembler, authorizer };
+    deps.connector.setInboundMediaDetectedHandler((msg) => handleInboundMedia(ctx, msg));
+    deps.connector.setMessageHandler((msg) => handleInboundMessage(ctx, msg));
+    deps.connector.setCardActionHandler((action) => handleCardAction(ctx, action));
 }
 //# sourceMappingURL=message-handlers.js.map

package/dist/model-catalog.d.ts

@@ -6,9 +6,9 @@
  * 「地基层被 runner 反向 import」；挪到这里后三方共同引用同一份。
  *
  * 表内容来自 Claude CLI 的模型别名（alias 是 CLI 侧的稳定名字，model ID 会随
- * 版本变），新增一行只改这里。
+ * 版本变），新增一行只改 MODEL_ID_TO_ALIAS，反向表自动派生。
  */
 /** 模型 ID → alias 映射。 */
 export declare const MODEL_ID_TO_ALIAS: Record<string, string>;
-/** alias → model ID 反向映射。 */
+/** alias → model ID 反向映射（从正向表派生，新增别名只改上面一张表）。 */
 export declare const MODEL_ALIAS_TO_ID: Record<string, string>;

package/dist/model-catalog.js

@@ -6,7 +6,7 @@
  * 「地基层被 runner 反向 import」；挪到这里后三方共同引用同一份。
  *
  * 表内容来自 Claude CLI 的模型别名（alias 是 CLI 侧的稳定名字，model ID 会随
- * 版本变），新增一行只改这里。
+ * 版本变），新增一行只改 MODEL_ID_TO_ALIAS，反向表自动派生。
  */
 /** 模型 ID → alias 映射。 */
 export const MODEL_ID_TO_ALIAS = {
@@ -15,11 +15,6 @@ export const MODEL_ID_TO_ALIAS = {
     'claude-haiku-4-5-20250501': 'haiku',
     'claude-fable-5': 'fable',
 };
-/** alias → model ID 反向映射。 */
-export const MODEL_ALIAS_TO_ID = {
-    opus: 'claude-opus-4-8',
-    sonnet: 'claude-sonnet-4-6',
-    haiku: 'claude-haiku-4-5-20250501',
-    fable: 'claude-fable-5',
-};
+/** alias → model ID 反向映射（从正向表派生，新增别名只改上面一张表）。 */
+export const MODEL_ALIAS_TO_ID = Object.fromEntries(Object.entries(MODEL_ID_TO_ALIAS).map(([id, alias]) => [alias, id]));
 //# sourceMappingURL=model-catalog.js.map

package/dist/platform/identity.js

@@ -154,7 +154,7 @@ export function binaryName(token, platform = currentPlatform) {
     return caseInsensitive(platform) ? name.toLowerCase() : name;
 }
 /**
- * 命令行与期望二进制是否属于同一程序（review 2026-09-05 收紧 + 2026-09-20 分档）。
+ * 命令行与期望二进制是否属于同一程序。
  *
  * 1. 可执行位匹配：首 token 的 basename 相等——`/usr/local/bin/claude --verbose`
  *    匹配 claude；native 单文件 CLI（claude 的 `bin/claude.exe`）也走这条；

package/dist/platform/path.d.ts

@@ -21,7 +21,7 @@ export declare function samePath(a: string, b: string, opts?: PathOptions): bool
  * cwd → 会话项目目录名（Claude/pi 的 on-disk 编码，lossy N-to-N）。
  *
  * 只可用于**定位**目录，绝不可反解回 cwd——cwd 必须从 JSONL 内容读取
- * （回归 2026-06-21 /resume & /cd 路径错乱）。
+ * （否则 /resume & /cd 路径会错乱）。
  *
  * posix：`/` → `-`（`_` 同样归一，与 Claude Code 一致）。
  * win32：`\` 与 `/` **都是**分隔符、`:` 是非法文件名字符，三者都必须归一，

package/dist/platform/path.js

@@ -63,7 +63,7 @@ export function samePath(a, b, opts) {
  * cwd → 会话项目目录名（Claude/pi 的 on-disk 编码，lossy N-to-N）。
  *
  * 只可用于**定位**目录，绝不可反解回 cwd——cwd 必须从 JSONL 内容读取
- * （回归 2026-06-21 /resume & /cd 路径错乱）。
+ * （否则 /resume & /cd 路径会错乱）。
  *
  * posix：`/` → `-`（`_` 同样归一，与 Claude Code 一致）。
  * win32：`\` 与 `/` **都是**分隔符、`:` 是非法文件名字符，三者都必须归一，

package/dist/platform/sleep-blocker.js

@@ -6,7 +6,7 @@ import { getLogger } from '../logger/index.js';
  * **必须按无符号 32 位取值**：`0x80000001` = 2147483649 超出 Int32 正数上界
  * （2147483647），而 PowerShell 的数字字面量按 Int32 解析 —— 十六进制写法一旦
  * 进了脚本就会被解析成 **-2147483647**，传给 P/Invoke 声明的 `uint` 形参时抛
- * `MethodArgumentConversionInvalidCastArgument`（2026-09-22 真机复现）。
+ * `MethodArgumentConversionInvalidCastArgument`。
  */
 const ES_FLAGS_UINT32 = (0x80000000 | 0x00000001) >>> 0;
 /**

package/dist/platform/terminator-win32.js

@@ -42,8 +42,9 @@ export function createWin32Terminator(deps) {
                 stdio: 'ignore',
                 windowsHide: true,
             });
-            killer?.on?.('error', () => {
+            killer?.on?.('error', (err) => {
                 // taskkill 拉起失败不致命：调用方仍可走 killOrphan / 陈旧锁自愈
+                log?.(`win32 树杀失败：taskkill error 事件 ${err?.message ?? err}`);
             });
         }
         catch (error) {