lark-remote 0.5.10 → 0.5.13

package/dist/runner/dsh/mux-stream.js

@@ -0,0 +1,157 @@
+import { getLogger } from '../../logger/index.js';
+import { DshError } from './errors.js';
+export async function* openMuxStream(opts) {
+    const cookie = await opts.authCookie();
+    const socket = opts.webSocketFactory(`${opts.baseUrl.replace(/^http/, 'ws')}/api/remote.mux`, cookie ? { headers: { cookie } } : undefined);
+    const streamId = `lr-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const queue = [];
+    let waiter = null;
+    let ended = false;
+    let failure;
+    let opened = false;
+    const settle = (frame) => {
+        if (waiter) {
+            const resolve = waiter;
+            waiter = null;
+            resolve(frame);
+            return;
+        }
+        if (frame)
+            queue.push(frame);
+        else
+            ended = true;
+    };
+    const connectTimer = setTimeout(() => {
+        if (opened || ended)
+            return;
+        failure = new DshError('transport', 'DSH remote mux WebSocket connect timeout');
+        ended = true;
+        settle(undefined);
+        try {
+            socket.close();
+        }
+        catch {
+            /* ignore close error */
+        }
+    }, opts.requestTimeoutMs);
+    connectTimer.unref?.();
+    socket.onopen = () => {
+        opened = true;
+        clearTimeout(connectTimer);
+        if (ended)
+            return;
+        try {
+            socket.send(JSON.stringify({
+                type: 'open',
+                streamId,
+                endpoint: opts.endpoint,
+                payload: opts.payload,
+            }));
+        }
+        catch (err) {
+            failure = new DshError('transport', `DSH remote mux send error: ${err.message}`);
+            ended = true;
+            settle(undefined);
+        }
+    };
+    socket.onmessage = (event) => {
+        if (ended)
+            return;
+        const text = typeof event.data === 'string'
+            ? event.data
+            : Buffer.isBuffer(event.data)
+                ? event.data.toString('utf8')
+                : String(event.data);
+        let message;
+        try {
+            message = JSON.parse(text);
+        }
+        catch {
+            getLogger().warn('[dsh] dropped malformed remote mux frame');
+            return;
+        }
+        if (message.streamId !== streamId)
+            return;
+        if (message.type === 'item' && message.value) {
+            settle(message.value);
+            return;
+        }
+        if (message.type === 'end') {
+            ended = true;
+            settle(undefined);
+            return;
+        }
+        if (message.type === 'error') {
+            failure = new DshError(message.error?.code ?? 'stream', message.error?.message ?? 'DSH remote stream failed', message.error?.details ?? {});
+            ended = true;
+            settle(undefined);
+        }
+    };
+    socket.onerror = () => {
+        if (ended)
+            return;
+        failure = new DshError('transport', 'DSH remote mux WebSocket error');
+        ended = true;
+        settle(undefined);
+    };
+    socket.onunexpectedresponse = (event) => {
+        if (ended)
+            return;
+        const status = event.statusCode;
+        failure = new DshError('http', `DSH remote mux WebSocket HTTP ${status === undefined ? 'error' : status}`, status === undefined ? {} : { status });
+        ended = true;
+        settle(undefined);
+    };
+    socket.onclose = () => {
+        if (ended)
+            return;
+        ended = true;
+        settle(undefined);
+    };
+    const onAbort = () => {
+        if (ended)
+            return;
+        ended = true;
+        settle(undefined);
+        try {
+            socket.close();
+        }
+        catch {
+            /* ignore close error */
+        }
+    };
+    opts.signal.addEventListener('abort', onAbort, { once: true });
+    const next = () => new Promise((resolve) => {
+        if (queue.length > 0) {
+            resolve(queue.shift());
+            return;
+        }
+        if (ended) {
+            resolve(undefined);
+            return;
+        }
+        waiter = resolve;
+    });
+    try {
+        while (!opts.signal.aborted) {
+            const frame = await next();
+            if (frame === undefined) {
+                if (failure && !opts.signal.aborted)
+                    throw failure;
+                return;
+            }
+            yield frame;
+        }
+    }
+    finally {
+        clearTimeout(connectTimer);
+        opts.signal.removeEventListener('abort', onAbort);
+        try {
+            socket.close();
+        }
+        catch {
+            /* ignore close error */
+        }
+    }
+}
+//# sourceMappingURL=mux-stream.js.map

package/dist/runner/dsh/runner.d.ts

@@ -230,6 +230,13 @@ export declare class DshRunner implements AgentRunner {
      * that is the only client-side protection against a late orphan turn.
      */
     private findPendingPromptWithin;
+    /**
+     * cancel 确认 closed 后的收尾：cancel 是 keepInbox，prompt 可能仍在 inbox。
+     * 在则撤回（防被下一个 turn 隐形认领），确认不在（已被本 turn 消费）或
+     * 撤回成功才清 inflight 标记；探测/撤回失败保留标记，交给下次启动的
+     * reconcile（findPendingPrompt 落空即自然清除，无副作用）。
+     */
+    private withdrawPendingPromptAfterCancel;
     private removePendingPrompt;
     /** One cancel attempt, then one retry (the request is idempotent when idle). */
     private cancelWithRetry;

package/dist/runner/dsh/runner.js

@@ -1216,8 +1216,14 @@ export class DshRunner {
             const state = await this.waitForClosed(sessionId, deadline);
             if (state === 'closed') {
                 releaseGate();
-                if (promptRequestId)
-                    this.inflight?.clear(sessionId, promptRequestId);
+                // cancel 是 keepInbox：prompt 可能仍在 inbox 里，等下一个无人订阅的
+                // turn 认领（探测超时/迟到 admit 退到 cancel 分支时，
+                // 旧实现直接清 inflight 标记——被停的 prompt 会被后续 turn 隐形执行
+                //（耗 token、改工作区，卡片不可见），启动对账安全网也被解除）。
+                // closed 后补一次撤回：在 inbox 就撤走，确认不在才清标记。
+                if (promptRequestId) {
+                    await this.withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline);
+                }
                 getLogger().info(`[dsh] cancelled session ${sessionId}`);
                 return { status: 'cancelled', sessionId };
             }
@@ -1233,8 +1239,9 @@ export class DshRunner {
             const retryState = await this.waitForClosed(sessionId, deadline);
             releaseGate();
             if (retryState === 'closed') {
-                if (promptRequestId)
-                    this.inflight?.clear(sessionId, promptRequestId);
+                if (promptRequestId) {
+                    await this.withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline);
+                }
                 return { status: 'cancelled', sessionId };
             }
             getLogger().warn(`[dsh] stop unconfirmed session=${sessionId}: turn still open`);
@@ -1268,12 +1275,42 @@ export class DshRunner {
                     return undefined;
             }
             catch (err) {
+                // 单次探测错误只消耗一次尝试（不提前放弃）：探测失败就 return 会把
+                // 仍在 inbox 的 prompt 交给 cancel 分支处理——cancel 是 keepInbox，
+                // prompt 会留到下一个无人订阅的 turn 被隐形执行。
                 getLogger().warn(`[dsh] stop inbox probe failed session=${sessionId}: ${err.message}`);
-                return undefined;
+                continue;
             }
         }
         return undefined;
     }
+    /**
+     * cancel 确认 closed 后的收尾：cancel 是 keepInbox，prompt 可能仍在 inbox。
+     * 在则撤回（防被下一个 turn 隐形认领），确认不在（已被本 turn 消费）或
+     * 撤回成功才清 inflight 标记；探测/撤回失败保留标记，交给下次启动的
+     * reconcile（findPendingPrompt 落空即自然清除，无副作用）。
+     */
+    async withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline) {
+        try {
+            const itemId = await this.client.findPendingPrompt(sessionId, promptRequestId, {
+                timeoutMs: this.stopProbeTimeout(deadline),
+            });
+            if (itemId) {
+                const removed = await this.client.removeQueuedPrompt(sessionId, itemId, {
+                    timeoutMs: this.stopProbeTimeout(deadline),
+                });
+                if (removed) {
+                    getLogger().info(`[dsh] stop withdrew inbox prompt left behind by cancel session=${sessionId}`);
+                    this.inflight?.clear(sessionId, promptRequestId);
+                }
+                return;
+            }
+            this.inflight?.clear(sessionId, promptRequestId);
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] post-cancel withdraw probe failed session=${sessionId}: ${err.message}`);
+        }
+    }
     async removePendingPrompt(sessionId, itemId, deadline) {
         try {
             return await this.client.removeQueuedPrompt(sessionId, itemId, {

package/dist/runner/dsh/translator.d.ts

@@ -25,13 +25,6 @@
  */
 import type { AgentEvent, ResultEvent } from '../types.js';
 import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from './types.js';
-/** 本 turn 各采样用量之和（input 是非缓存输入，与 ccusage/ResultEvent 口径一致）。 */
-interface UsageTotals {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-}
 export declare class DshTranslator {
     /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
     private turnUsage;
@@ -63,6 +56,3 @@ export declare class DshTranslator {
 }
 /** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
 export declare function mapUsage(u: DshTokenUsage): NonNullable<ResultEvent['usage']>;
-/** Map a turn's summed usage → ResultEvent.usage (cacheWrite = cache creation). */
-export declare function mapAggregatedUsage(t: UsageTotals): NonNullable<ResultEvent['usage']>;
-export {};

package/dist/runner/dsh/translator.js

@@ -265,7 +265,7 @@ export function mapUsage(u) {
     });
 }
 /** Map a turn's summed usage → ResultEvent.usage (cacheWrite = cache creation). */
-export function mapAggregatedUsage(t) {
+function mapAggregatedUsage(t) {
     return {
         input_tokens: t.input,
         output_tokens: t.output,

package/dist/runner/index.d.ts

@@ -15,6 +15,6 @@ export { KimiAcpRunner } from './kimi/index.js';
 export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, FinalAnswerEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

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

@@ -144,6 +144,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
      */
     compactBaselineRecords = [];
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    // 已知限制（待验证 kimi 0.4x 契约）：句柄只在
+    // terminal/release 与连接关闭（cleanupTerminals）时删除。若服务端只 kill
+    // 不 release（中断 turn 的场景），已退出进程的句柄（含 ≤4MB output 缓冲）
+    // 会滞留到连接释放。kimi 契约上工具结束会发 release（mock 测试同驱动）；
+    // 若真机确认存在只 kill 不 release 的路径，再补 exit 后延迟回收。
     terminals = new Map();
     /** terminalId 自增序号（term-1, term-2, …）。 */
     terminalSeq = 0;
@@ -422,6 +427,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         while (true) {
             if (this.forceFinish || this.stopRequested)
                 return 'stopped';
+            // turn 已死亡（failTurn，如连接关闭）时不再轮询：forceFinish 与
+            // stopRequested 均为 false 的死亡路径会让循环空转到 10 分钟沉默超时，
+            // 结果还被 isCurrent() 丢弃——纯浪费的每秒文件读。
+            if (!this._isRunning)
+                return 'unknown';
             const records = reader.call(this.sessionReader, sessionId, opts.cwd);
             if (records.length !== lastTotalCount) {
                 lastTotalCount = records.length;
@@ -506,8 +516,15 @@ export class KimiAcpRunner extends BaseAcpRunner {
             // (error = "rejected"), otherwise the server hangs waiting for a
             // response. For question elicitation (§5.4), auto-respond cancelled.
             const rpParams = params;
-            if (method === ServerRequestMethod.REQUEST_PERMISSION &&
-                (rpParams.isQuestion || !rpParams.toolCall)) {
+            // elicitation/create 的表单属性全不可解析时（translator 返回 []）同样回
+            // cancelled 而不是 METHOD_NOT_FOUND：§5.4 的不变量是「识别到非工具审批
+            // 形态 → 自动回应 cancelled，防止服务端挂起」；错误响应虽也能解悬挂，
+            // 但 kimi 侧可能把 JSON-RPC error 当工具级失败让整个 turn 报错，而不是
+            // 跳过提问继续。
+            const isQuestionElicitation = method === ServerRequestMethod.REQUEST_PERMISSION &&
+                (rpParams.isQuestion || !rpParams.toolCall);
+            const isUnparseableElicitationForm = method === ServerRequestMethod.ELICITATION_CREATE;
+            if (isQuestionElicitation || isUnparseableElicitationForm) {
                 this.currentClient?.respond(id, { outcome: { outcome: 'cancelled' } });
                 getLogger().info(`[${this.logTag}] auto-responded cancelled to question elicitation requestId=${id}`);
             }
@@ -633,8 +650,27 @@ export class KimiAcpRunner extends BaseAcpRunner {
         proc.once('exit', (code, signal) => {
             handle.exitCode = code;
             handle.signal = signal;
-            resolveExit?.();
-            emitResult();
+            // 'exit' 可先于 stdout 缓冲派发：立刻 emit 会按旧快照推送 tool_result，
+            // 卡片面板丢尾部输出（terminal/output 反向 RPC 读到的是补齐后的全量，
+            // 只影响卡片）。等流 end 或 200ms 宽限——不等 'close'：它要等所有共享
+            // 管道的子孙进程退出，`nohup &` 类后台任务会把它拖到永远。
+            //
+            // wait_for_exit 必须在 tool_result 入队之后才 resolve：服务端拿到响应
+            // 后会立刻 release + end_turn，先 resolve 会让回合结果早于延迟推送的
+            // tool_result 到达，Bash 输出被丢弃（卡片面板空输出）。
+            const flushThenEmit = () => {
+                clearTimeout(emitTimer);
+                emitResult();
+                resolveExit?.();
+            };
+            const emitTimer = setTimeout(flushThenEmit, 200);
+            emitTimer.unref?.();
+            if (proc.stdout && !proc.stdout.destroyed) {
+                proc.stdout.once('end', flushThenEmit);
+            }
+            else {
+                flushThenEmit();
+            }
         });
         proc.once('error', (err) => {
             getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
@@ -642,8 +678,9 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 handle.exitCode = 1;
                 handle.signal = null;
             }
-            resolveExit?.();
+            // 同 exit：tool_result 先入队，再放行 wait_for_exit。
             emitResult();
+            resolveExit?.();
         });
         const terminalId = `term-${++this.terminalSeq}`;
         this.terminals.set(terminalId, handle);

package/dist/runner/kimi/acp/translator.d.ts

@@ -29,6 +29,14 @@ import { type RequestPermissionParams, type AgentMessageChunkEvent, type AgentTh
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
 export declare class KimiAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "kimi-acp-translator";
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    protected emitToolResultForNonTerminalUpdate(content: unknown): boolean;
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     private textByItem;
     /** Accumulated thinking per item. */

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

@@ -42,6 +42,16 @@ const THINKING_ITEM_ID = 'thinking';
 // =============================================================================
 export class KimiAcpTranslator extends BaseAcpTranslator {
     logTag = 'kimi-acp-translator';
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    emitToolResultForNonTerminalUpdate(content) {
+        return !(content === undefined || content === null || content === '');
+    }
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     textByItem = new Map();
     /** Accumulated thinking per item. */
@@ -149,18 +159,7 @@ export class KimiAcpTranslator extends BaseAcpTranslator {
             // 才提供「本会话总是允许」（acceptForSession）；否则与旧行为一致。
             availableDecisions: deriveAcpAvailableDecisions(params.options ?? []),
         };
-        return [
-            {
-                type: 'approval_requested',
-                requestId,
-                kind: 'command',
-                threadId: params.sessionId,
-                turnId: '',
-                itemId: '',
-                view,
-                timestamp: new Date().toISOString(),
-            },
-        ];
+        return this.approvalRequestedEvents(requestId, params.sessionId, view);
     }
     handleOtherServerRequest(requestId, method, params) {
         if (method !== ServerRequestMethod.ELICITATION_CREATE) {

package/dist/runner/opencode/acp/translator.js

@@ -189,18 +189,7 @@ export class OpencodeAcpTranslator extends BaseAcpTranslator {
             // 才提供「本会话总是允许」（acceptForSession）。
             availableDecisions: deriveAcpAvailableDecisions(params.options ?? []),
         };
-        return [
-            {
-                type: 'approval_requested',
-                requestId,
-                kind: 'command',
-                threadId: params.sessionId,
-                turnId: '',
-                itemId: '',
-                view,
-                timestamp: new Date().toISOString(),
-            },
-        ];
+        return this.approvalRequestedEvents(requestId, params.sessionId, view);
     }
 }
 // =============================================================================

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

@@ -113,9 +113,24 @@ export class PiRpcRunner extends ConnectionBasedRunner {
         const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
         this.manager.notifyActivity(opts.cwd);
         this.currentClient = client;
+        // 轮次代际锚点（与 BaseAcpRunner 同口径）：pi 的 shouldReuse 要求
+        // sessionId 匹配，/new、/resume 切换后的首条消息会让 acquire **同步
+        // dispose** 旧连接；terminator 等到进程退出后，旧 client 上残留的上一轮
+        // onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即丢失）。
+        // 旧轮迟到的 agent_settled 同理（新 turn 空转立即"成功"）。所有 hook
+        // 落地前必须过 isCurrentTurn。
+        const generation = this.turnGeneration;
         client.setHooks({
-            onEvent: (evt) => this.handleEvent(evt),
-            onClose: () => this.failTurn('Pi RPC connection closed'),
+            onEvent: (evt) => {
+                if (!this.isCurrentTurn(generation, client))
+                    return;
+                this.handleEvent(evt);
+            },
+            onClose: () => {
+                if (!this.isCurrentTurn(generation, client))
+                    return;
+                this.failTurn('Pi RPC connection closed');
+            },
         });
         let sessionId = opts.sessionId;
         if (!sessionId) {
@@ -157,9 +172,19 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
             this.manager.notifyActivity(opts.cwd);
             this.currentClient = client;
+            // 同 setupTurn：hook 带轮次代际锚点，旧连接的迟到回调不得进入本轮。
+            const generation = this.turnGeneration;
             client.setHooks({
-                onEvent: (evt) => this.handleEvent(evt),
-                onClose: () => this.failTurn('Pi RPC connection closed'),
+                onEvent: (evt) => {
+                    if (!this.isCurrentTurn(generation, client))
+                        return;
+                    this.handleEvent(evt);
+                },
+                onClose: () => {
+                    if (!this.isCurrentTurn(generation, client))
+                        return;
+                    this.failTurn('Pi RPC connection closed');
+                },
             });
             this.activeSessionId = opts.sessionId;
             const translator = new PiRpcTranslator();
@@ -170,7 +195,10 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             this.currentTurnId = turnId;
             this.pushEvents([translator.produceTurnStarted(opts.sessionId, turnId)]);
             this.promptSettled = false;
-            const response = await client.request({ type: 'compact' });
+            // compact 是完整的 LLM 请求（同步跑完才回响应，协议文档自述），大上下文
+            // 压缩轻松超过默认 60s 请求超时——超时只会出假错误卡，压缩仍在后台完成。
+            // 活性交给 turn idle 看门狗与 /stop（与 ACP 侧 turn 级请求同口径）。
+            const response = await client.request({ type: 'compact' }, Number.POSITIVE_INFINITY);
             this.promptSettled = true;
             // Guard: a stop may have already ended this turn (deferred-stop during
             // compaction) — don't push a stale result into a (possibly reused) queue.

package/dist/runner/pi/rpc/translator.d.ts

@@ -10,15 +10,9 @@
  *     `result` from that response.
  *   - `agent_settled` is ignored for compaction turns (no double result).
  */
-import type { AgentEvent, ResultEvent } from '../../types.js';
+import type { AgentEvent, ResultEvent, TurnStartedEvent } from '../../types.js';
 import { type PiRpcEvent, type PiRpcResponse } from './protocol-types.js';
-export interface PiRpcTurnStartedEvent {
-    type: 'turn_started';
-    threadId: string;
-    turnId: string;
-    operationKind: 'turn' | 'compaction';
-    timestamp?: string;
-}
+export type PiRpcTurnStartedEvent = TurnStartedEvent;
 export type PiRpcTranslatorEvent = AgentEvent | PiRpcTurnStartedEvent;
 export declare class PiRpcTranslator {
     private content;

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

@@ -10,6 +10,7 @@
  *     `result` from that response.
  *   - `agent_settled` is ignored for compaction turns (no double result).
  */
+import { makeTurnStartedEvent } from '../../common/turn-started.js';
 export class PiRpcTranslator {
     content = [];
     currentContentIndex = -1;
@@ -135,13 +136,7 @@ export class PiRpcTranslator {
     /** Self-produced turn_started (no wire equivalent). */
     produceTurnStarted(sessionId, turnId) {
         this.sessionId = sessionId;
-        return {
-            type: 'turn_started',
-            threadId: sessionId,
-            turnId,
-            operationKind: this.operationKind === 'compact' ? 'compaction' : 'turn',
-            timestamp: new Date().toISOString(),
-        };
+        return makeTurnStartedEvent(sessionId, turnId, this.operationKind);
     }
     /** Result for a completed normal turn (agent_settled). */
     produceResultFromSettled() {

package/dist/runner/registry.d.ts

@@ -14,28 +14,9 @@ import type { AgentKind, Runner } from './index.js';
  */
 export declare class AgentRegistry {
     private readonly factories;
-    private readonly displayNames;
     /** Container for runtime config updates (pi provider dynamic reload). */
     private configContainer?;
     register(kind: AgentKind, factory: (cwd: string) => Runner): void;
-    /**
-     * 注册 agent 的显示名。应在 register(kind, factory) 后调用。
-     * 用于 agentDisplayName 等全局查询，实现单点真相。
-     */
-    registerDisplayName(kind: AgentKind, displayName: string): void;
-    /**
-     * 获取 agent 显示名。未注册时返回原始 kind。
-     */
-    getDisplayName(kind: AgentKind): string;
-    /**
-     * 设置全局 registry 实例，供 agentDisplayName 等全局函数使用。
-     * 在 index.ts 初始化所有 agents 后调用。
-     */
-    static setGlobalInstance(reg: AgentRegistry | undefined): void;
-    /**
-     * 获取全局 registry 实例。
-     */
-    static getGlobalInstance(): AgentRegistry | undefined;
     /**
      * Set config container reference. Call after bridge config is updated.
      * Factory functions can read latest config from here.

package/dist/runner/registry.js

@@ -1,8 +1,3 @@
-/**
- * 单例 registry 实例，供 agentDisplayName 等全局查询使用。
- * 在 index.ts 初始化后设置。
- */
-let globalRegistry;
 /**
  * Registry of agent factories, keyed by `AgentKind`. `index.ts` registers one
  * factory per available agent at startup; `Bridge.getRunner(cwd)` looks
@@ -18,38 +13,11 @@ let globalRegistry;
  */
 export class AgentRegistry {
     factories = new Map();
-    displayNames = new Map();
     /** Container for runtime config updates (pi provider dynamic reload). */
     configContainer;
     register(kind, factory) {
         this.factories.set(kind, factory);
     }
-    /**
-     * 注册 agent 的显示名。应在 register(kind, factory) 后调用。
-     * 用于 agentDisplayName 等全局查询，实现单点真相。
-     */
-    registerDisplayName(kind, displayName) {
-        this.displayNames.set(kind, displayName);
-    }
-    /**
-     * 获取 agent 显示名。未注册时返回原始 kind。
-     */
-    getDisplayName(kind) {
-        return this.displayNames.get(kind) ?? kind;
-    }
-    /**
-     * 设置全局 registry 实例，供 agentDisplayName 等全局函数使用。
-     * 在 index.ts 初始化所有 agents 后调用。
-     */
-    static setGlobalInstance(reg) {
-        globalRegistry = reg;
-    }
-    /**
-     * 获取全局 registry 实例。
-     */
-    static getGlobalInstance() {
-        return globalRegistry;
-    }
     /**
      * Set config container reference. Call after bridge config is updated.
      * Factory functions can read latest config from here.

package/dist/runner/resolve-agent-choices.js

@@ -25,7 +25,11 @@ export function resolveAgentChoices(config) {
     const source = agentChoices;
     for (const { configKey, choicesKey } of fields) {
         const value = source[choicesKey];
-        if (!target[configKey] && value) {
+        // 只填「配置里根本没写」的字段（undefined）：显式清空（config.yaml 写了
+        // `model: ""`）是用户意志，旧真值判断 `!target[configKey]` 会把空串当
+        // 「未配置」，用残留 choices 把清空值填回去——重启后永远回不到默认。
+        // value 为空串同样不填（choices 里记录的「跟随默认」）。
+        if (target[configKey] === undefined && value) {
             target[configKey] = value;
         }
     }

package/dist/runner/sync-agent-choices.js

@@ -14,7 +14,10 @@ export function syncAgentChoices(config, agent) {
     const source = agentCfg;
     for (const { configKey, choicesKey } of fields) {
         const value = source[configKey];
-        if (value)
+        // 显式空串也要同步（用户清空 = 回到默认）：旧真值判断不同步空串，
+        // agentChoices 里残留上一次的选择——/config 卡片显示的与实际生效的
+        // 配置从此分叉，重启后 resolve 还会把残留填回 config。
+        if (value !== undefined)
             agentChoices[choicesKey] = value;
     }
     return updated;