lark-remote 0.1.8 → 0.1.9

package/dist/runner/claude/session.d.ts

@@ -46,6 +46,11 @@ export interface ClaudeSessionOptions {
 export interface PermissionResult {
     behavior: 'allow' | 'deny';
     message?: string;
+    /**
+     * allow 时显式覆盖 updatedInput（默认回写 pendingToolInputs 原始 input）。
+     * 计划审批「批准并采纳修改意见」用它携带改写的 plan。
+     */
+    updatedInput?: unknown;
 }
 /**
  * ClaudeSession extends SpawningRunner 复用其 spawn/pid 文件/killOrphan/
@@ -74,6 +79,12 @@ export declare class ClaudeSession extends SpawningRunner {
     private waitResolve;
     /** 待审批的 control_request 原始 input（回写 updatedInput 需要）。 */
     private pendingToolInputs;
+    /**
+     * 本会话内跟踪到的计划文件路径：Write/Edit 工具把文件写到 `plans` 目录
+     * 时记录（ExitPlanMode 的 plan 内容不总是经 input 注入，文件是可靠兜底）。
+     * 会话进程生命周期内有效（长驻进程 = 一个会话）。
+     */
+    private planFilePath;
     /** 允许所有：后续 control_request 自动 allow（本会话进程生命周期内有效）。 */
     private autoApprove;
     /** 串行化 stdin 写入（用户消息与审批响应交错到达）。 */
@@ -160,6 +171,21 @@ export declare class ClaudeSession extends SpawningRunner {
      */
     private writeStdin;
     private translateEvent;
+    /**
+     * 跟踪会话内 Write/Edit 工具写到 `plans` 目录的文件路径：CLI 对
+     * ExitPlanMode 的 plan 注入不稳定（input.plan 时有时无），但模型被要求
+     * 先把计划写入计划文件，路径可经工具调用可靠捕获（含模型写错目录的
+     * 退化场景——渲染层可展示实际落盘位置）。
+     */
+    private trackPlanFilePath;
+    /**
+     * ExitPlanMode 计划解析，优先级：
+     * 1. control_request input.plan（CLI normalizeToolInput 从磁盘注入，非稳定）；
+     * 2. input.planFilePath 指向的文件；
+     * 3. 会话内 Write/Edit 跟踪到的计划文件。
+     * 全部落空时返回空对象，渲染层展示「未获取到计划文件内容」兜底。
+     */
+    private resolvePlanContent;
     private translateControlRequest;
     /** 统一方案：所有 runner 自己生成 timestamp（缺失时补）。 */
     private withTimestamp;

package/dist/runner/claude/session.js

@@ -27,6 +27,7 @@
  * 进程在 turn 之间保持存活（stdin 不关闭），/stop / /new / /cd / 看门狗超时
  * 时经 ProcessStopper 组杀，下条消息按 SessionStore 的 sessionId --resume。
  */
+import { readFile } from 'node:fs/promises';
 import { silentlyUnlink } from '../../common/fs.js';
 import { getLogger } from '../../logger/index.js';
 import { SpawningRunner } from '../common/spawning-runner.js';
@@ -35,6 +36,8 @@ import { authErrorEvent, syntheticInitEvent } from '../common/runner-utils.js';
 import { makeQuestionApprovalEvent } from '../question-common.js';
 /** 拒绝权限时的默认提示（进入 claude 上下文，中文用户可读）。 */
 const DENY_MESSAGE = '用户拒绝了此工具调用，请停止并等待用户指令。';
+/** ExitPlanMode 计划文件读取上限（超出截断，防超大计划拖垮事件翻译）。 */
+const MAX_PLAN_CHARS = 60_000;
 /** 会话级空闲回收默认 TTL（对齐 codex appServer.idleTtlMs 默认 30 分钟）。 */
 const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000;
 /** result 事件里表示「turn 中途压缩」的 subtype（不是 turn 结束）。 */
@@ -66,6 +69,12 @@ export class ClaudeSession extends SpawningRunner {
     waitResolve = null;
     /** 待审批的 control_request 原始 input（回写 updatedInput 需要）。 */
     pendingToolInputs = new Map();
+    /**
+     * 本会话内跟踪到的计划文件路径：Write/Edit 工具把文件写到 `plans` 目录
+     * 时记录（ExitPlanMode 的 plan 内容不总是经 input 注入，文件是可靠兜底）。
+     * 会话进程生命周期内有效（长驻进程 = 一个会话）。
+     */
+    planFilePath = '';
     /** 允许所有：后续 control_request 自动 allow（本会话进程生命周期内有效）。 */
     autoApprove = false;
     /** 串行化 stdin 写入（用户消息与审批响应交错到达）。 */
@@ -182,7 +191,9 @@ export class ClaudeSession extends SpawningRunner {
         if (result.behavior === 'allow') {
             await this.writeControlResponse(requestId, {
                 behavior: 'allow',
-                updatedInput: input ?? {},
+                // 显式 updatedInput 优先（计划审批「批准并采纳修改」携带改写 plan）；
+                // 缺省回写原始 input，保证其他工具审批行为不变。
+                updatedInput: result.updatedInput !== undefined ? result.updatedInput : (input ?? {}),
             });
         }
         else {
@@ -344,7 +355,7 @@ export class ClaudeSession extends SpawningRunner {
                 for await (const raw of stream) {
                     if (generation !== this.processGeneration)
                         return; // 旧进程残留事件丢弃
-                    const events = this.translateEvent(raw);
+                    const events = await this.translateEvent(raw);
                     if (events.length > 0) {
                         this.eventQueue.push(...events);
                         this.wakeWaiters();
@@ -530,7 +541,7 @@ export class ClaudeSession extends SpawningRunner {
     // =========================================================================
     // Internal: event translation
     // =========================================================================
-    translateEvent(raw) {
+    async translateEvent(raw) {
         const event = raw;
         const type = event.type;
         // review P3-3：--resume 会先重放上一轮历史事件（旧 result 之外还可能有
@@ -538,6 +549,10 @@ export class ClaudeSession extends SpawningRunner {
         // 内容混进当前卡片（result 分支的 sawInit 守卫升级为全类型守卫）。
         if (type !== 'system' && !this.sawInit)
             return [];
+        // 跟踪会话内计划文件写入（ExitPlanMode 审批卡的 plan 文件兜底）。
+        if (type === 'assistant') {
+            this.trackPlanFilePath(event);
+        }
         if (type === 'control_request') {
             return this.translateControlRequest(event);
         }
@@ -588,7 +603,63 @@ export class ClaudeSession extends SpawningRunner {
         // 下游 reducer 忽略，保留诊断价值。
         return [this.withTimestamp(event)];
     }
-    translateControlRequest(raw) {
+    /**
+     * 跟踪会话内 Write/Edit 工具写到 `plans` 目录的文件路径：CLI 对
+     * ExitPlanMode 的 plan 注入不稳定（input.plan 时有时无），但模型被要求
+     * 先把计划写入计划文件，路径可经工具调用可靠捕获（含模型写错目录的
+     * 退化场景——渲染层可展示实际落盘位置）。
+     */
+    trackPlanFilePath(raw) {
+        const content = raw.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            const b = block;
+            if (b?.type !== 'tool_use')
+                continue;
+            if (b.name !== 'Write' && b.name !== 'Edit')
+                continue;
+            const fp = b.input?.file_path;
+            if (typeof fp === 'string' && fp.includes('/plans/')) {
+                this.planFilePath = fp;
+            }
+        }
+    }
+    /**
+     * ExitPlanMode 计划解析，优先级：
+     * 1. control_request input.plan（CLI normalizeToolInput 从磁盘注入，非稳定）；
+     * 2. input.planFilePath 指向的文件；
+     * 3. 会话内 Write/Edit 跟踪到的计划文件。
+     * 全部落空时返回空对象，渲染层展示「未获取到计划文件内容」兜底。
+     */
+    async resolvePlanContent(input, trackedPath) {
+        const direct = typeof input.plan === 'string' && input.plan.trim() ? input.plan : undefined;
+        if (direct !== undefined) {
+            // 计划已随 input 注入时仍携带文件路径（input.planFilePath 或会话内跟踪），
+            // 供卡片展示「计划落盘位置」。
+            const filePath = typeof input.planFilePath === 'string' && input.planFilePath
+                ? input.planFilePath
+                : trackedPath;
+            return filePath ? { plan: direct, planFilePath: filePath } : { plan: direct };
+        }
+        const candidate = typeof input.planFilePath === 'string' && input.planFilePath
+            ? input.planFilePath
+            : trackedPath;
+        if (!candidate)
+            return {};
+        try {
+            const content = await readFile(candidate, 'utf8');
+            const trimmed = content.trim();
+            if (trimmed) {
+                return { plan: trimmed.slice(0, MAX_PLAN_CHARS), planFilePath: candidate };
+            }
+        }
+        catch {
+            // 计划文件缺失/不可读：fall through，渲染层兜底。
+        }
+        return {};
+    }
+    async translateControlRequest(raw) {
         const requestId = raw.request_id;
         if (requestId === null || requestId === undefined) {
             getLogger().warn(`[${this.logTag}] control_request missing request_id, dropping`);
@@ -642,21 +713,27 @@ export class ClaudeSession extends SpawningRunner {
             }
             return [makeQuestionApprovalEvent(requestId, questions, this.sessionId)];
         }
-        // ExitPlanMode：语义是「退出计划模式」的通知型工具，input 天然为空（plan
-        // 内容在 plan 文件 + 前置 thinking/text 里，不走 tool input）。它没有
-        // command 语义，塞进 command 槽位会显示无意义 `{}` → 用独立 tool kind，
-        // 标题/工具名 + reason 表达审批内容。
+        // ExitPlanMode：计划已写入计划文件（或经 input.plan 注入）。没有 command
+        // 语义，塞进 command 槽位会显示无意义 `{}` → 用独立 tool kind，把计划
+        // 全文 + 文件路径带给渲染层，决策对齐 TUI 四种交互。
         if (toolName === 'ExitPlanMode') {
-            const rawInput = JSON.stringify(input);
+            const resolved = await this.resolvePlanContent(input, this.planFilePath);
             const view = {
                 requestId,
                 kind: 'tool',
                 toolName,
                 reason: typeof request.description === 'string' ? request.description : undefined,
-                // 非空 input 携带给渲染层（当前 ExitPlanMode 为 `{}`，渲染层不展示）。
-                ...(rawInput && rawInput !== '{}' ? { toolInput: rawInput.slice(0, 500) } : {}),
-                // 计划审批没有「后续自动放行」语义，acceptAll 无意义；只留 accept/decline。
-                availableDecisions: ['accept', 'decline'],
+                ...(resolved.plan !== undefined ? { plan: resolved.plan } : {}),
+                ...(resolved.planFilePath !== undefined ? { planFilePath: resolved.planFilePath } : {}),
+                // 对齐 TUI：批准并执行 / 批准并自动放行（acceptAll）/ 拒绝并附意见 /
+                // 批准并采纳修改 / 拒绝。
+                availableDecisions: [
+                    'accept',
+                    'acceptAll',
+                    'declineWithFeedback',
+                    'acceptWithFeedback',
+                    'decline',
+                ],
             };
             getLogger().info(`[${this.logTag}] permission request requestId=${requestId} tool=${toolName}`);
             return [

package/dist/runner/common/connection-based-runner.js

@@ -104,18 +104,23 @@ export class ConnectionBasedRunner {
      * unblock; otherwise cancel now via cancelCurrentTurn().
      */
     async stop(_opts) {
-        if (!this._isRunning || !this.currentClient || !this.currentSessionId())
+        if (!this._isRunning)
             return;
+        // CC-01: 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
+        // turn 照常执行。executeTurn 在 setup 完成后检查 stopRequested 补发 cancel。
+        this.stopRequested = true;
+        this.forceFinish = true;
+        this.wakeWaiters();
+        if (!this.currentClient || !this.currentSessionId()) {
+            getLogger().warn(`[${this.logTag}] stop during setup (client/session not ready); will cancel after setup`);
+            return;
+        }
         if (this.shouldDeferStop()) {
             // turn/start 或 prompt 尚未响应：先标记，等 run() 完成后再补发 cancel。
-            this.stopRequested = true;
-            this.forceFinish = true;
-            this.wakeWaiters();
             return;
         }
         // turn/start 或 prompt 已 resolved：立即 cancel；同时置 stopRequested 抑制
         // 尚未结算的 prompt 结果翻译（opencode 语义），对已结算方无害。
-        this.stopRequested = true;
         try {
             await this.cancelCurrentTurn();
         }

package/dist/runner/dsh/runner.js

@@ -51,99 +51,119 @@ export class DshRunner {
         };
     }
     async *run(message, opts) {
+        if (this.running) {
+            throw new Error('DshRunner is already running');
+        }
         const abort = new AbortController();
         this.activeAbort = abort;
         this.running = true;
         let sessionId = opts.sessionId;
-        if (!sessionId) {
-            const created = await this.client.createSession({
-                cwd: opts.cwd,
-                ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
-            });
-            sessionId = created.sessionId;
-        }
-        this.activeSessionId = sessionId;
-        // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
-        // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
-        if (this.configuredModel) {
-            try {
-                await this.client.selectModel({
-                    sessionId,
-                    provider: DSH_MODEL_PROVIDER,
-                    model: this.configuredModel,
-                    ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+        let terminalEmitted = false;
+        try {
+            // CC-03: session.create 必须包进同一 try/finally，否则创建失败（服务端不可达/报错）
+            // 会在进入旧 try 之前抛异常，finally 不执行 → running 恒 true、activeAbort 残留。
+            if (!sessionId) {
+                const created = await this.client.createSession({
+                    cwd: opts.cwd,
+                    ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
                 });
+                sessionId = created.sessionId;
             }
-            catch (err) {
-                getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+            this.activeSessionId = sessionId;
+            // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
+            // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
+            if (this.configuredModel) {
+                try {
+                    await this.client.selectModel({
+                        sessionId,
+                        provider: DSH_MODEL_PROVIDER,
+                        model: this.configuredModel,
+                        ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+                    });
+                }
+                catch (err) {
+                    getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+                }
             }
-        }
-        yield {
-            type: 'system',
-            subtype: 'init',
-            session_id: sessionId,
-            cwd: opts.cwd,
-            model: this.configuredModel ?? 'DSH',
-        };
-        let terminalEmitted = false;
-        try {
-            // Snapshot the pre-prompt high-water mark before mutating the session.
-            // DSH session.history returns the whole session, so starting from seq 0
-            // would replay the first completed turn on every follow-up prompt.
-            const prePromptSeq = await this.client.latestEventSeq(sessionId);
-            await this.client.unary('session.prompt', {
-                sessionId,
-                mode: 'queue',
-                content: [{ type: 'text', text: message }],
-            });
-            const translator = new DshTranslator();
+            yield {
+                type: 'system',
+                subtype: 'init',
+                session_id: sessionId,
+                cwd: opts.cwd,
+                model: this.configuredModel ?? 'DSH',
+            };
             try {
-                for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
-                    if (abort.signal.aborted)
-                        break;
-                    if (item.kind === 'approval') {
-                        getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
-                        yield {
-                            type: 'assistant',
-                            message: {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
-                                    },
-                                ],
-                            },
-                        };
-                        continue;
-                    }
-                    for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
-                        yield ev;
-                        if (ev.type === 'result') {
-                            terminalEmitted = true;
-                            return;
+                // Snapshot the pre-prompt high-water mark before mutating the session.
+                // DSH session.history returns the whole session, so starting from seq 0
+                // would replay the first completed turn on every follow-up prompt.
+                const prePromptSeq = await this.client.latestEventSeq(sessionId);
+                await this.client.unary('session.prompt', {
+                    sessionId,
+                    mode: 'queue',
+                    content: [{ type: 'text', text: message }],
+                });
+                const translator = new DshTranslator();
+                try {
+                    for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
+                        if (abort.signal.aborted)
+                            break;
+                        if (item.kind === 'approval') {
+                            getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
+                            yield {
+                                type: 'assistant',
+                                message: {
+                                    content: [
+                                        {
+                                            type: 'text',
+                                            text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
+                                        },
+                                    ],
+                                },
+                            };
+                            continue;
+                        }
+                        for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
+                            yield ev;
+                            if (ev.type === 'result') {
+                                terminalEmitted = true;
+                                return;
+                            }
                         }
                     }
                 }
+                catch (err) {
+                    if (abort.signal.aborted)
+                        throw err;
+                    getLogger().error(`[dsh] run consume error: ${err.message}`);
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH stream error: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
             }
             catch (err) {
-                if (abort.signal.aborted)
-                    throw err;
-                getLogger().error(`[dsh] run consume error: ${err.message}`);
-                yield {
-                    type: 'result',
-                    subtype: 'error',
-                    session_id: sessionId,
-                    errorMessage: `DSH stream error: ${err.message}`,
-                };
-                terminalEmitted = true;
+                if (!abort.signal.aborted) {
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH run failed: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
             }
         }
         catch (err) {
+            // CC-03: createSession 等启动期失败也产出 error result（而非抛异常），
+            // 由本 catch 统一转 error result；state 清理在 finally。
             if (!abort.signal.aborted) {
                 yield {
                     type: 'result',
                     subtype: 'error',
-                    session_id: sessionId,
+                    session_id: sessionId ?? '',
                     errorMessage: `DSH run failed: ${err.message}`,
                 };
                 terminalEmitted = true;
@@ -158,7 +178,7 @@ export class DshRunner {
             yield {
                 type: 'result',
                 subtype: abort.signal.aborted ? 'interrupted' : 'error',
-                session_id: sessionId,
+                session_id: sessionId ?? '',
                 errorMessage: abort.signal.aborted ? 'run stopped' : 'turn ended without a terminal event',
             };
         }

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

@@ -405,6 +405,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             sessionId = newResult.sessionId;
         }
         this.activeSessionId = sessionId;
+        // CC-07: 下发配置的模型（provider/model）。session/new|resume 只带 cwd/mcpServers，
+        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型（旧 KimiRunner 通过 -m 传模型，
+        // 迁移到纯 ACP 后丢失）。仿 opencode 用 session/set_config_option。失败仅告警不阻断。
+        if (this.model) {
+            try {
+                await client.request('session/set_config_option', {
+                    sessionId,
+                    configId: 'model',
+                    value: this.model,
+                });
+            }
+            catch (err) {
+                getLogger().warn(`[${this.logTag}] set_config_option model failed (non-fatal): ${err.message}`);
+            }
+        }
         // Set permission mode (§5.1): EVERY fresh ACP session starts in
         // 'default' (= manual approvals, acp-server modes.ts DEFAULT_MODE_ID),
         // so the mode must be sent unconditionally — skipping yolo leaves the

package/dist/runner/pi/rpc/runner.js

@@ -134,7 +134,12 @@ export class PiRpcRunner extends ConnectionBasedRunner {
         this.currentTurnId = turnId;
         this.pushEvents([translator.produceTurnStarted(sessionId, turnId)]);
         this.promptSettled = false;
-        await client.request({ type: 'prompt', message });
+        const response = await client.request({ type: 'prompt', message });
+        if (!response.success) {
+            // CC-08: pi 返回 success:false（无效模型/provider 错误/忙）时立即失败，
+            // 不能当成成功 ACK 继续等 agent_settled（否则最长 turn idle timeout）。
+            throw new Error(`pi prompt failed: ${response.error ?? 'unknown error'}`);
+        }
         this.promptSettled = true;
     }
     /**

package/dist/runner/types.d.ts

@@ -69,6 +69,23 @@ export type ApprovalAction = {
 /** Claude：允许当前请求 + 本会话后续所有权限请求自动放行（允许所有）。 */
  | {
     action: 'accept_all';
+}
+/**
+ * 计划审批「拒绝并附修改意见」：deny + message，Claude 留在 plan 模式
+ * 按意见修订（等价 TUI「Tell Claude what to change」）。
+ */
+ | {
+    action: 'decline_with_feedback';
+    message: string;
+}
+/**
+ * 计划审批「批准并采纳修改意见」：allow + updatedInput.plan（原计划追加
+ * 意见），触发 Claude 侧 planWasEdited → tool_result 回显
+ * "## Approved Plan (edited by user)"（等价 TUI shift+tab approve with feedback）。
+ */
+ | {
+    action: 'accept_with_feedback';
+    plan: string;
 } | {
     action: 'decline';
 } | {
@@ -145,6 +162,20 @@ export interface ApprovalView {
      * 表达审批内容，避免落入 command 槽位显示无意义 `{}`。
      */
     toolName?: string;
+    /**
+     * 计划全文（kind === 'tool' 且 toolName === 'ExitPlanMode' 时存在）。
+     * 来源：control_request input.plan（CLI normalizeToolInput 从磁盘注入，
+     * 非稳定）→ 计划文件读取（input.planFilePath / 会话内 Write/Edit 跟踪）。
+     */
+    plan?: string;
+    /** 计划文件路径（ExitPlanMode；input.planFilePath 或会话内跟踪所得）。 */
+    planFilePath?: string;
+    /**
+     * 用户已填写的计划修改意见（ExitPlanMode 反馈输入框；coordinator
+     * planFeedback 回流，卡片回显）。供「拒绝并附意见」/「批准并采纳修改」
+     * 两个决策复用。
+     */
+    planFeedback?: string;
     /** 原始 input 的 JSON 字符串（kind === 'tool' 且 input 非空时展示）。 */
     toolInput?: string;
     fileChanges?: Array<{

package/dist/session/dsh/sessions.d.ts

@@ -15,13 +15,18 @@
 import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
 interface DshSessionReaderOptions {
     host?: string;
+    /** 每次调用时解析当前 host（/config 修改 host 后 runner 重建、reader 也跟随新 host）。
+     *  优先于固定的 `host`。 */
+    hostProvider?: () => string | undefined;
     /** Injectable synchronous unary transport. Defaults to spawnSync curl. */
     syncRequest?: (baseUrl: string, method: string, payload: unknown) => unknown;
 }
 export declare class DshSessionReader implements AgentSessionReader {
-    private readonly baseUrl;
+    private readonly hostProvider;
     private readonly syncRequest;
     constructor(opts?: DshSessionReaderOptions);
+    /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
+    private resolveBaseUrl;
     private unary;
     listSessions(cwd: string, opts?: {
         limit?: number;

package/dist/session/dsh/sessions.js

@@ -17,6 +17,13 @@ import { getLogger } from '../../logger/index.js';
 import { DEFAULT_DSH_HOST } from '../../config/index.js';
 import { capEvents, paginate } from '../common/pagination.js';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
+/**
+ * CC-05: history 拉取上限。DSH session.history 的 maxMessages 同时限制返回条数，
+ * 若用它同时充当展示截断，>50 事件的会话累计 usage 会少算。这里拉取一个足够大的
+ * 上限保证 usage 累加覆盖整个会话；展示仍由 capEvents(opts?.maxEvents ?? 50) 截断。
+ * （若 DSH 支持分页 cursor 可改成分页，当前用有界大拉取，见 review-fix-plan-cc.md）
+ */
+const DSH_HISTORY_FETCH_LIMIT = 10_000;
 /** Synchronous unary POST via curl (the reader interface is synchronous). */
 function defaultSyncRequest(baseUrl, method, payload) {
     const body = JSON.stringify({
@@ -53,14 +60,20 @@ function defaultSyncRequest(baseUrl, method, payload) {
     return parsed.result.value;
 }
 export class DshSessionReader {
-    baseUrl;
+    hostProvider;
     syncRequest;
     constructor(opts = {}) {
-        this.baseUrl = (opts.host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
+        const fixed = (opts.host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
+        this.hostProvider = opts.hostProvider ?? (() => fixed);
         this.syncRequest = opts.syncRequest ?? defaultSyncRequest;
     }
+    /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
+    resolveBaseUrl() {
+        const host = this.hostProvider();
+        return (host && host.length > 0 ? host : DEFAULT_DSH_HOST).replace(/\/$/, '');
+    }
     unary(method, payload) {
-        return this.syncRequest(this.baseUrl, method, payload);
+        return this.syncRequest(this.resolveBaseUrl(), method, payload);
     }
     listSessions(cwd, opts) {
         try {
@@ -90,7 +103,7 @@ export class DshSessionReader {
         try {
             const value = this.unary('session.history', {
                 sessionId,
-                maxMessages: opts?.maxEvents ?? 50,
+                maxMessages: DSH_HISTORY_FETCH_LIMIT,
             });
             const events = [];
             let displayTitle;
@@ -142,7 +155,9 @@ export class DshSessionReader {
                 };
             }
             return {
-                events: capEvents(events, opts?.maxEvents),
+                // CC-05: 展示仍按 maxEvents 尾截断（默认 50，保持原行为），usage 已在上面基于
+                // 完整 history 累加。
+                events: capEvents(events, opts?.maxEvents ?? 50),
                 ...(sessionUsage ? { usage: sessionUsage } : {}),
                 ...(displayTitle ? { displayTitle } : {}),
             };

package/dist/workspace/index.d.ts

@@ -14,6 +14,8 @@ export interface WorkspaceEntry {
  * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
  * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
  * 对新保存的 workspace 同样生效（新条目应排在列表最前，而非沉底）。
+ * 同一毫秒内连续操作时 touch 会用 max+1 保证严格递增，避免 Date.now 相同
+ * 导致最近排序退化为字母序。
  *
  * Data migration: old format `{ alias: "path" }` is normalized to
  * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
@@ -31,6 +33,12 @@ export declare class WorkspaceStore {
     /**
      * Update lastUsedAt to now for the given alias and persist.
      * No-op if the alias does not exist.
+     *
+     * To keep "recent" ordering stable even for rapid successive saves/uses in
+     * the same millisecond, never allow another entry to share the same
+     * timestamp while this entry is being touched. If a peer already has a
+     * timestamp at or after the current wall-clock time, use max+1 so the
+     * touched entry always becomes the most recently used.
      */
     touch(name: string): void;
     /**