lark-remote 0.4.3 → 0.4.5

package/dist/runner/common/acp/{protocol-helpers.js → acp-approval.js}

@@ -1,5 +1,6 @@
 /**
- * Shared helper functions for the ACP protocol layer.
+ * ACP approval/permission mapping and lifecycle shared by the kimi and
+ * opencode ACP runners.
  *
  * Extracted from runner.ts and translator.ts to avoid duplication (G5).
  * Shape source: approval.ts:28-29 — optionId is opaque, echo back as-is.
@@ -11,7 +12,7 @@ import { getLogger } from '../../../logger/index.js';
  * ACP option kind values vary between kimi versions; this handles both
  * the documented names and the observed real names (§2.3).
  */
-export function findOptionIdByKind(options, candidateKinds) {
+function findOptionIdByKind(options, candidateKinds) {
     for (const kind of candidateKinds) {
         const found = options.find((opt) => opt.kind === kind);
         if (found)
@@ -100,4 +101,4 @@ export async function sendAcpSetMode(opts) {
         getLogger().warn(`[${opts.logTag}] session/set_mode failed (non-fatal): ${err.message}`);
     }
 }
-//# sourceMappingURL=protocol-helpers.js.map
+//# sourceMappingURL=acp-approval.js.map

package/dist/runner/common/acp/base-acp-runner.d.ts

@@ -22,7 +22,7 @@ import type { AgentEvent, AgentKind, AgentSessionReader, SpawnOptions } from '..
 import { ConnectionManager } from '../jsonrpc/connection-manager.js';
 import { JsonRpcClient } from '../jsonrpc/client.js';
 import { type SessionNewResult, type SessionResumeResult, type SessionPromptResult, type RequestPermissionParams } from './protocol-types.js';
-import { type AcpPendingApproval } from './protocol-helpers.js';
+import { type AcpPendingApproval } from './acp-approval.js';
 import { ConnectionBasedRunner } from '../connection-based-runner.js';
 import { BaseAcpTranslator, type AcpTranslatorEvent } from './base-translator.js';
 export type { AcpTranslatorEvent } from './base-translator.js';

package/dist/runner/common/acp/base-acp-runner.js

@@ -1,4 +1,4 @@
-import { respondAcpApproval, sendAcpSetMode, truncateWithEllipsis, } from './protocol-helpers.js';
+import { respondAcpApproval, sendAcpSetMode, truncateWithEllipsis, } from './acp-approval.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../connection-based-runner.js';
 export class BaseAcpRunner extends ConnectionBasedRunner {

package/dist/runner/common/acp/base-translator.d.ts

@@ -15,6 +15,8 @@
  *   handleRequestPermission                           — approval rendering (abstract)
  *   handleOtherServerRequest                          — extra reverse RPC (kimi: elicitation)
  *   extractToolResultContent                          — tool_result content (default: rawOutput)
+ *   extractToolCallArgsText                           — streaming-args source (opencode: none)
+ *   buildToolUseUpdate                                — tool_use patch from tool_call_update
  *   onUsageSample                                     — extra usage bookkeeping (opencode: cost)
  */
 import type { AgentEvent, ApprovalRequestedEvent, ResultEvent } from '../../types.js';
@@ -69,6 +71,13 @@ export declare abstract class BaseAcpTranslator {
      * approval handler correlate by toolCallId and recover the real command.
      */
     private toolCallArgsByCallId;
+    /**
+     * tool_use name recorded at tool_call time (kind mapping wins, else title).
+     * A later tool_call_update may carry only a title (opencode's completed
+     * update has neither kind nor rawInput); pairing it with the recorded name
+     * lets a tool_use patch render the original title as a subtitle.
+     */
+    private toolCallNameByCallId;
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -132,8 +141,42 @@ export declare abstract class BaseAcpTranslator {
      * command (see toolCallArgsByCallId).
      */
     protected getTrackedToolCallArgs(toolCallId: string): string | undefined;
+    /** tool_use name recorded at tool_call time (kind mapping wins, else title). */
+    protected getToolCallName(toolCallId: string): string | undefined;
+    /**
+     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * handler and the tool_call_update patch builder so both agree on the name.
+     */
+    protected toolNameFromKind(kind: string | undefined): string | undefined;
+    /**
+     * Streaming-args text carried by a tool_call/_update notification.
+     *
+     * Default: the notification's content text — kimi's events-map.ts encodes the
+     * accumulated args there (toolCallDeltaToSessionUpdate: content.text =
+     * accumulator.args), and the approval handler relies on it.
+     *
+     * opencode overrides this to return undefined: its tool_call/_update content
+     * is the shell OUTPUT snapshot (decompiled acp service `WP`), never args
+     * (args ride rawInput in `XC`/`BP`). Treating that output as args would
+     * corrupt approval command recovery — the hazard this hook exists to close.
+     */
+    protected extractToolCallArgsText(event: ToolCallEvent | ToolCallUpdateEvent): string | undefined;
+    /**
+     * tool_call_update → optional tool_use patch event. When an update carries
+     * richer identity than the initial tool_call did (opencode emits the
+     * tool_call while args are still streaming, then delivers the real title /
+     * rawInput in later updates), the returned `assistant`/`tool_use` block is
+     * merged into the existing tool block by the card reducer (matched by id)
+     * instead of creating a duplicate panel.
+     *
+     * Default: null (kimi self-produces its Bash tool_use from terminal/create
+     * with the real command, so it needs no patch). opencode overrides.
+     */
+    protected buildToolUseUpdate(_event: ToolCallUpdateEvent): AgentEvent | null;
     /** Record latest args text, bounded so a long session cannot grow it forever. */
     private trackToolCallArgs;
+    /** Record tool_use name, bounded to keep a long session from growing it. */
+    private trackToolCallName;
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT

package/dist/runner/common/acp/base-translator.js

@@ -65,6 +65,13 @@ export class BaseAcpTranslator {
      * approval handler correlate by toolCallId and recover the real command.
      */
     toolCallArgsByCallId = new Map();
+    /**
+     * tool_use name recorded at tool_call time (kind mapping wins, else title).
+     * A later tool_call_update may carry only a title (opencode's completed
+     * update has neither kind nor rawInput); pairing it with the recorded name
+     * lets a tool_use patch render the original title as a subtitle.
+     */
+    toolCallNameByCallId = new Map();
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -231,15 +238,16 @@ export class BaseAcpTranslator {
                 // Keep raw string as-is
             }
         }
-        const argsText = extractToolCallContentText(event.content);
+        const argsText = this.extractToolCallArgsText(event);
         if (argsText !== undefined) {
             this.trackToolCallArgs(event.toolCallId, argsText);
         }
         else if (event.rawInput !== undefined && event.rawInput !== null) {
             this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
         }
-        const mapped = event.kind ? KIND_TO_TOOL[event.kind] : undefined;
+        const mapped = this.toolNameFromKind(event.kind);
         const name = mapped ?? event.title;
+        this.trackToolCallName(event.toolCallId, name);
         const summary = mapped && event.title && event.title !== name ? event.title : undefined;
         return [
             {
@@ -265,6 +273,11 @@ export class BaseAcpTranslator {
     handleToolCallUpdate(event, _sessionId) {
         const isError = event.status === 'failed';
         const content = this.extractToolResultContent(event);
+        // Patch the existing tool block with identity that was not available at the
+        // initial tool_call (opencode streams args after emitting tool_call). The
+        // reducer merges by id, so this never duplicates the panel. Built before
+        // the terminal cleanup below so it can still resolve the recorded name.
+        const useUpdate = this.buildToolUseUpdate(event);
         // Terminal updates end the args-streaming phase — drop the tracked entry.
         // In-progress delta text is cumulative (events-map.ts
         // toolCallDeltaToSessionUpdate: content.text = accumulator.args), so the
@@ -273,7 +286,7 @@ export class BaseAcpTranslator {
             this.toolCallArgsByCallId.delete(event.toolCallId);
         }
         else {
-            const argsText = extractToolCallContentText(event.content);
+            const argsText = this.extractToolCallArgsText(event);
             if (argsText !== undefined) {
                 this.trackToolCallArgs(event.toolCallId, argsText);
             }
@@ -281,22 +294,24 @@ export class BaseAcpTranslator {
                 this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
             }
         }
-        return [
-            {
-                type: 'user',
-                message: {
-                    content: [
-                        {
-                            type: 'tool_result',
-                            tool_use_id: event.toolCallId,
-                            content,
-                            is_error: isError,
-                        },
-                    ],
-                },
-                timestamp: new Date().toISOString(),
+        const events = [];
+        if (useUpdate)
+            events.push(useUpdate);
+        events.push({
+            type: 'user',
+            message: {
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: event.toolCallId,
+                        content,
+                        is_error: isError,
+                    },
+                ],
             },
-        ];
+            timestamp: new Date().toISOString(),
+        });
+        return events;
     }
     /**
      * Latest tracked streaming-args text for a tool call (undefined when never
@@ -307,6 +322,46 @@ export class BaseAcpTranslator {
     getTrackedToolCallArgs(toolCallId) {
         return this.toolCallArgsByCallId.get(toolCallId);
     }
+    /** tool_use name recorded at tool_call time (kind mapping wins, else title). */
+    getToolCallName(toolCallId) {
+        return this.toolCallNameByCallId.get(toolCallId);
+    }
+    /**
+     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * handler and the tool_call_update patch builder so both agree on the name.
+     */
+    toolNameFromKind(kind) {
+        return kind ? KIND_TO_TOOL[kind] : undefined;
+    }
+    /**
+     * Streaming-args text carried by a tool_call/_update notification.
+     *
+     * Default: the notification's content text — kimi's events-map.ts encodes the
+     * accumulated args there (toolCallDeltaToSessionUpdate: content.text =
+     * accumulator.args), and the approval handler relies on it.
+     *
+     * opencode overrides this to return undefined: its tool_call/_update content
+     * is the shell OUTPUT snapshot (decompiled acp service `WP`), never args
+     * (args ride rawInput in `XC`/`BP`). Treating that output as args would
+     * corrupt approval command recovery — the hazard this hook exists to close.
+     */
+    extractToolCallArgsText(event) {
+        return extractToolCallContentText(event.content);
+    }
+    /**
+     * tool_call_update → optional tool_use patch event. When an update carries
+     * richer identity than the initial tool_call did (opencode emits the
+     * tool_call while args are still streaming, then delivers the real title /
+     * rawInput in later updates), the returned `assistant`/`tool_use` block is
+     * merged into the existing tool block by the card reducer (matched by id)
+     * instead of creating a duplicate panel.
+     *
+     * Default: null (kimi self-produces its Bash tool_use from terminal/create
+     * with the real command, so it needs no patch). opencode overrides.
+     */
+    buildToolUseUpdate(_event) {
+        return null;
+    }
     /** Record latest args text, bounded so a long session cannot grow it forever. */
     trackToolCallArgs(toolCallId, argsText) {
         this.toolCallArgsByCallId.delete(toolCallId);
@@ -317,6 +372,16 @@ export class BaseAcpTranslator {
                 this.toolCallArgsByCallId.delete(oldest);
         }
     }
+    /** Record tool_use name, bounded to keep a long session from growing it. */
+    trackToolCallName(toolCallId, name) {
+        this.toolCallNameByCallId.delete(toolCallId);
+        this.toolCallNameByCallId.set(toolCallId, name);
+        if (this.toolCallNameByCallId.size > 100) {
+            const oldest = this.toolCallNameByCallId.keys().next().value;
+            if (oldest !== undefined)
+                this.toolCallNameByCallId.delete(oldest);
+        }
+    }
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT

package/dist/runner/common/connection-based-runner.d.ts

@@ -60,9 +60,9 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
      * 两件事，顺序不能反：
      *   1. 若本连接就是当前在途 turn 的连接，先发协议取消（codex turn/interrupt /
      *      ACP session/cancel / pi abort）。**归属判定不能省**：runner 实例按 agent
-     *      维度共享（一个实例管多条 workspace 连接），无条件调用
+     *      维度共享（一个实例管多条 cwd 连接），无条件调用
      *      `cancelCurrentTurn()` 会用它自己的 currentClient/activeSessionId 去打断
-     *      **另一个 workspace** 正在跑的 turn；
+     *      **另一个 cwd** 正在跑的 turn；
      *   2. 关 stdin。stdio 型 agent server 在 stdin EOF 后自行退出——只发协议取消
      *      不会让进程退出，优雅段会空转到 grace 超时后照样树杀，等于通道白注册。
      */
@@ -118,9 +118,9 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
     protected respawnAfterConnectionLost(opts: SpawnOptions): Promise<void>;
     /** Hook: clear subclass turn state in run() finally (session ids, translator, flags). */
     protected abstract clearTurnState(): void;
-    /** Release the connection for a workspace (subclass dispatches to its manager). */
+    /** Release the connection for a cwd (subclass dispatches to its manager). */
     protected abstract releaseConnection(cwd: string): Promise<void>;
-    /** Notify the connection manager that the workspace is idle (subclass). */
+    /** Notify the connection manager that the cwd is idle (subclass). */
     protected abstract notifyIdle(cwd: string): void;
     /** Dispose all connections (subclass dispatches to its manager). */
     protected abstract disposeConnections(): Promise<void>;

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

@@ -1,6 +1,6 @@
 import { ConnectionLostError } from './jsonrpc/client.js';
 import { getLogger } from '../../logger/index.js';
-import { syntheticInitEvent } from './runner-utils.js';
+import { syntheticInitEvent } from './synthetic-events.js';
 import { DEFAULT_TURN_IDLE_TIMEOUT_MINUTES } from '../../config/index.js';
 /** How long to wait for turn output notifications before failing.
  *  30 分钟（单源于 config 的 DEFAULT_TURN_IDLE_TIMEOUT_MINUTES）：ACP/app-server
@@ -37,9 +37,9 @@ export class ConnectionBasedRunner {
      * 两件事，顺序不能反：
      *   1. 若本连接就是当前在途 turn 的连接，先发协议取消（codex turn/interrupt /
      *      ACP session/cancel / pi abort）。**归属判定不能省**：runner 实例按 agent
-     *      维度共享（一个实例管多条 workspace 连接），无条件调用
+     *      维度共享（一个实例管多条 cwd 连接），无条件调用
      *      `cancelCurrentTurn()` 会用它自己的 currentClient/activeSessionId 去打断
-     *      **另一个 workspace** 正在跑的 turn；
+     *      **另一个 cwd** 正在跑的 turn；
      *   2. 关 stdin。stdio 型 agent server 在 stdin EOF 后自行退出——只发协议取消
      *      不会让进程退出，优雅段会空转到 grace 超时后照样树杀，等于通道白注册。
      */

package/dist/runner/common/jsonrpc/connection-manager.d.ts

@@ -1,9 +1,9 @@
 /**
- * ConnectionManager: manages agent-server connections per workspace, shared by
+ * ConnectionManager: manages agent-server connections per cwd, shared by
  * all workspace-lifetime JSON-line runners (codex app-server, kimi acp,
  * opencode acp, and pi rpc).
  *
- * Each workspace gets its own connection (transport + client). Connections are
+ * Each cwd gets its own connection (transport + client). Connections are
  * created on demand via `acquire()`, cached for reuse, and released after an
  * idle timeout (30 minutes default).
  *
@@ -92,7 +92,7 @@ export declare class ConnectionManager<TClient extends ConnectionClient = JsonRp
     private readonly logTag;
     private readonly stoppers;
     /** Callback when a connection is lost — cleared from slot map. */
-    onConnectionLost?: (workspace: string) => void;
+    onConnectionLost?: (cwd: string) => void;
     /**
      * 协议停止通道工厂（design §3.3）：连接建立后按 pid 登记到 AgentStopperRegistry，
      * 供 Terminator 在**优雅**停止时回调（win32 上没有可拦截的 SIGTERM，只能靠
@@ -108,37 +108,37 @@ export declare class ConnectionManager<TClient extends ConnectionClient = JsonRp
     }) => AgentStopper | undefined;
     constructor(opts: ConnectionManagerOptions<TClient>);
     /**
-     * Acquire a connection for the given workspace.
+     * Acquire a connection for the given cwd.
      * Creates a new connection if one does not exist or the previous one was lost
      * (or, for session-bound protocols, bound to a different session).
      * Serializes creation so concurrent calls share the same connection.
      */
-    acquire(workspace: string, req?: AcquireRequest): Promise<TClient>;
+    acquire(cwd: string, req?: AcquireRequest): Promise<TClient>;
     /**
      * Record the session id a fresh connection actually bound to (e.g. discovered
      * via a protocol `get_state` after a fresh spawn). This lets a subsequent run
      * resume the SAME session on the live connection instead of respawning it.
      */
-    bindSession(workspace: string, sessionId: string): void;
+    bindSession(cwd: string, sessionId: string): void;
     /**
-     * Release (dispose) a connection for the given workspace.
+     * Release (dispose) a connection for the given cwd.
      */
-    release(workspace: string): Promise<void>;
+    release(cwd: string): Promise<void>;
     /**
      * Dispose all connections.
      */
     disposeAll(): Promise<void>;
     /**
-     * Notify that the workspace is active — disarm the idle timer.
+     * Notify that the cwd is active — disarm the idle timer.
      */
-    notifyActivity(workspace: string): void;
+    notifyActivity(cwd: string): void;
     /**
-     * Notify that the workspace is idle — arm the idle timer.
+     * Notify that the cwd is idle — arm the idle timer.
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
      */
-    notifyIdle(workspace: string): void;
+    notifyIdle(cwd: string): void;
     private createClient;
     private clearIdleTimer;
     private disposeSlot;

package/dist/runner/common/jsonrpc/connection-manager.js

@@ -1,9 +1,9 @@
 /**
- * ConnectionManager: manages agent-server connections per workspace, shared by
+ * ConnectionManager: manages agent-server connections per cwd, shared by
  * all workspace-lifetime JSON-line runners (codex app-server, kimi acp,
  * opencode acp, and pi rpc).
  *
- * Each workspace gets its own connection (transport + client). Connections are
+ * Each cwd gets its own connection (transport + client). Connections are
  * created on demand via `acquire()`, cached for reuse, and released after an
  * idle timeout (30 minutes default).
  *
@@ -62,13 +62,13 @@ export class ConnectionManager {
         this.stoppers = opts.stoppers ?? agentStopperRegistry;
     }
     /**
-     * Acquire a connection for the given workspace.
+     * Acquire a connection for the given cwd.
      * Creates a new connection if one does not exist or the previous one was lost
      * (or, for session-bound protocols, bound to a different session).
      * Serializes creation so concurrent calls share the same connection.
      */
-    async acquire(workspace, req = {}) {
-        const existing = this.slots.get(workspace);
+    async acquire(cwd, req = {}) {
+        const existing = this.slots.get(cwd);
         if (existing) {
             // If a create is in flight, wait for it
             if (existing.createPromise) {
@@ -85,10 +85,10 @@ export class ConnectionManager {
             })) {
                 return existing.client;
             }
-            this.disposeSlot(workspace);
+            this.disposeSlot(cwd);
         }
-        const createPromise = this.createClient(workspace, req);
-        this.slots.set(workspace, {
+        const createPromise = this.createClient(cwd, req);
+        this.slots.set(cwd, {
             client: null, // placeholder
             boundSessionId: req.sessionId,
             idleTimer: null,
@@ -99,11 +99,11 @@ export class ConnectionManager {
             // 竞态：创建期间 release()/disposeAll() 已把 slot 删掉（并可能已
             // dispose 连接）。此时不能再把新连接塞回 slot——否则会复活一个无人管理、
             // 无 idle timer 的连接泄漏。归还给调用者继续使用，但不再缓存。
-            const slotAfterCreate = this.slots.get(workspace);
+            const slotAfterCreate = this.slots.get(cwd);
             if (!slotAfterCreate || slotAfterCreate.createPromise !== createPromise) {
                 return client;
             }
-            this.slots.set(workspace, {
+            this.slots.set(cwd, {
                 client,
                 boundSessionId: req.sessionId,
                 idleTimer: null,
@@ -114,9 +114,9 @@ export class ConnectionManager {
         catch (err) {
             // 只删除自己的槽位：并发 release + 重新 acquire 后 slot 可能已被新的
             // createPromise 占据，误删会破坏新连接。
-            const current = this.slots.get(workspace);
+            const current = this.slots.get(cwd);
             if (current && current.createPromise === createPromise) {
-                this.slots.delete(workspace);
+                this.slots.delete(cwd);
             }
             throw err;
         }
@@ -126,16 +126,16 @@ export class ConnectionManager {
      * via a protocol `get_state` after a fresh spawn). This lets a subsequent run
      * resume the SAME session on the live connection instead of respawning it.
      */
-    bindSession(workspace, sessionId) {
-        const slot = this.slots.get(workspace);
+    bindSession(cwd, sessionId) {
+        const slot = this.slots.get(cwd);
         if (slot)
             slot.boundSessionId = sessionId;
     }
     /**
-     * Release (dispose) a connection for the given workspace.
+     * Release (dispose) a connection for the given cwd.
      */
-    async release(workspace) {
-        this.disposeSlot(workspace);
+    async release(cwd) {
+        this.disposeSlot(cwd);
     }
     /**
      * Dispose all connections.
@@ -145,46 +145,46 @@ export class ConnectionManager {
         await Promise.all(workspaces.map((w) => this.disposeSlot(w)));
     }
     /**
-     * Notify that the workspace is active — disarm the idle timer.
+     * Notify that the cwd is active — disarm the idle timer.
      */
-    notifyActivity(workspace) {
-        const slot = this.slots.get(workspace);
+    notifyActivity(cwd) {
+        const slot = this.slots.get(cwd);
         if (slot) {
             this.clearIdleTimer(slot);
         }
     }
     /**
-     * Notify that the workspace is idle — arm the idle timer.
+     * Notify that the cwd is idle — arm the idle timer.
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
      */
-    notifyIdle(workspace) {
+    notifyIdle(cwd) {
         if (this.idleTtlMs <= 0)
             return;
-        const slot = this.slots.get(workspace);
+        const slot = this.slots.get(cwd);
         if (slot) {
             this.clearIdleTimer(slot);
             slot.idleTimer = setTimeout(() => {
-                getLogger().info(`[${this.logTag}] idle timeout for workspace=${workspace}, releasing connection`);
-                this.disposeSlot(workspace);
+                getLogger().info(`[${this.logTag}] idle timeout for cwd=${cwd}, releasing connection`);
+                this.disposeSlot(cwd);
             }, this.idleTtlMs);
         }
     }
     // =========================================================================
     // Internal
     // =========================================================================
-    async createClient(workspace, req) {
+    async createClient(cwd, req) {
         let client = null;
         const transport = new JsonlRpcTransport({
             binary: this.binary,
             args: this.buildArgs(req),
-            cwd: workspace,
+            cwd: cwd,
             env: this.env,
             stoppers: this.stoppers,
             // 通道工厂要拿到**连接本身**：协议取消（codex turn/interrupt、ACP
             // session/cancel）必须发在这条连接上，不能借 runner 的共享状态——那会
-            // 打断另一 workspace 正在跑的 turn。工厂是在 transport.start() 内侧调用
+            // 打断另一 cwd 正在跑的 turn。工厂是在 transport.start() 内侧调用
             // 的，那时 client 已由下面的 clientFactory 赋好。
             stopper: this.stopper
                 ? (pid) => this.stopper?.({ pid, client: client })
@@ -194,12 +194,12 @@ export class ConnectionManager {
             transport,
             requestTimeoutMs: this.requestTimeoutMs,
             baseOnClose: () => {
-                getLogger().info(`[${this.logTag}] connection closed workspace=${workspace}`);
+                getLogger().info(`[${this.logTag}] connection closed cwd=${cwd}`);
                 // 只清理自己创建的 slot：并发 release + 重新 acquire 后 slot 可能已被
                 // 新连接占据，误删会破坏新连接。
-                if (this.slots.get(workspace)?.client === client) {
-                    this.slots.delete(workspace);
-                    this.onConnectionLost?.(workspace);
+                if (this.slots.get(cwd)?.client === client) {
+                    this.slots.delete(cwd);
+                    this.onConnectionLost?.(cwd);
                 }
             },
         });
@@ -212,18 +212,18 @@ export class ConnectionManager {
             slot.idleTimer = null;
         }
     }
-    async disposeSlot(workspace) {
-        const slot = this.slots.get(workspace);
+    async disposeSlot(cwd) {
+        const slot = this.slots.get(cwd);
         if (!slot)
             return;
-        this.slots.delete(workspace);
+        this.slots.delete(cwd);
         this.clearIdleTimer(slot);
         if (slot.client) {
             try {
                 await slot.client.dispose();
             }
             catch (err) {
-                getLogger().warn(`[${this.logTag}] dispose error workspace=${workspace}: ${err}`);
+                getLogger().warn(`[${this.logTag}] dispose error cwd=${cwd}: ${err}`);
             }
         }
     }

package/dist/runner/common/{usage.d.ts → result-usage.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Normalized usage extracted from a result event.
  *
- * @module runner/common/usage
+ * @module runner/common/result-usage
  */
 import type { TokenUsage } from '../types.js';
 /** Normalized, camelCase view of a `TokenUsage` payload.

package/dist/runner/common/{usage.js → result-usage.js}

@@ -1,7 +1,7 @@
 /**
  * Normalized usage extracted from a result event.
  *
- * @module runner/common/usage
+ * @module runner/common/result-usage
  */
 // ---------------------------------------------------------------------------
 // Implementation
@@ -30,4 +30,4 @@ export function normalizeResultUsage(usage) {
         contextLength,
     };
 }
-//# sourceMappingURL=usage.js.map
+//# sourceMappingURL=result-usage.js.map

package/dist/runner/common/spawning-runner.d.ts

@@ -86,7 +86,7 @@ export declare abstract class SpawningRunner {
     private stopperRegistration;
     constructor(opts: {
         pidDir?: string;
-        workspace: string;
+        cwd: string;
         stopGraceMs?: number;
         spawnHeartbeatMs?: number;
         /**
@@ -127,7 +127,7 @@ export declare abstract class SpawningRunner {
      * finite timeout (review P2-11) against the 'error' event: Node guarantees
      * 'error' for ENOENT/EACCES, but some binaries fail silently without ever
      * emitting it. Without the race, the spawn lead-in hangs forever → the
-     * workspace serial queue never settles → permanent deadlock, and /stop
+     * cwd serial queue never settles → permanent deadlock, and /stop
      * can't recover (Terminator.stop returns early when pid === undefined).
      * The timeout keeps the deadlock bounded.
      */