lark-remote 0.4.4 → 0.5.0

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

@@ -114,7 +114,7 @@ export declare abstract class BaseAcpTranslator {
      */
     setOperationKind(kind: 'turn' | 'compact'): void;
     /**
-     * plan update → PlanEvent（信息保真 C3.2：不再显式丢弃）。
+     * plan update → PlanEvent（信息保真 不再显式丢弃）。
      * ACP PlanEntry: { content, priority, status }（status: pending/in_progress/
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
@@ -125,7 +125,7 @@ export declare abstract class BaseAcpTranslator {
      * JSON.parse (older agents send JSON strings) — keeps the card from
      * crashing on undefined input.
      *
-     * 信息保真 C3.1：kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
+     * 信息保真 kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
      * title 与 name 不同时把 title 存到 content block 的 summary 字段
      * （渲染层做面板副标题）。
      */
@@ -144,7 +144,7 @@ export declare abstract class BaseAcpTranslator {
     /** 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
+     * kind → canonical tool name (信息保真). 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;

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

@@ -1,6 +1,6 @@
 import { NotificationMethod, ServerRequestMethod, SessionEventType, } from './protocol-types.js';
 /**
- * ACP tool kind → 常用工具名映射（信息保真 C3.1，数据驱动无 agent 分支）。
+ * ACP tool kind → 常用工具名映射（信息保真，数据驱动无 agent 分支）。
  * kind 命中映射时用映射名渲染结构化面板；否则回落 title（维持现状）。
  */
 const KIND_TO_TOOL = {
@@ -199,7 +199,7 @@ export class BaseAcpTranslator {
     // Shared notification handlers
     // =========================================================================
     /**
-     * plan update → PlanEvent（信息保真 C3.2：不再显式丢弃）。
+     * plan update → PlanEvent（信息保真 不再显式丢弃）。
      * ACP PlanEntry: { content, priority, status }（status: pending/in_progress/
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
@@ -224,7 +224,7 @@ export class BaseAcpTranslator {
      * JSON.parse (older agents send JSON strings) — keeps the card from
      * crashing on undefined input.
      *
-     * 信息保真 C3.1：kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
+     * 信息保真 kind 命中 KIND_TO_TOOL 时用映射名渲染结构化面板；
      * title 与 name 不同时把 title 存到 content block 的 summary 字段
      * （渲染层做面板副标题）。
      */
@@ -327,7 +327,7 @@ export class BaseAcpTranslator {
         return this.toolCallNameByCallId.get(toolCallId);
     }
     /**
-     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * kind → canonical tool name (信息保真). Shared by the initial tool_call
      * handler and the tool_call_update patch builder so both agree on the name.
      */
     toolNameFromKind(kind) {

package/dist/runner/common/acp/protocol-types.js

@@ -45,7 +45,7 @@ export const RpcErrorCode = {
 //
 // REAL envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}}.
 // The discriminator field is `update.sessionUpdate` — there is NO nested
-// `event.type` / `event.delta` (S5/S6 打回根因：旧实现读 params.event，
+// `event.type` / `event.delta` (旧实现读 params.event，
 // 真实通知全部静默丢弃)。
 // =============================================================================
 /** Notification method names for ACP protocol. */

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

@@ -51,7 +51,7 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
     /** Set up the turn: acquire + thread|session new/resume + prompt. */
     protected abstract setupTurn(message: string, opts: SpawnOptions): Promise<void>;
     /**
-     * 本连接的协议停止通道（design §3.3）。
+     * 本连接的协议停止通道。
      *
      * win32 上「优雅停止」没有可拦截的跨进程 SIGTERM，只能经 agent 自有协议通道
      * 请求对方收摊。子类把这个方法的结果交给 ConnectionManager.stopper，由后者按
@@ -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
@@ -28,7 +28,7 @@ export class ConnectionBasedRunner {
         this.turnIdleTimeoutMs = opts.turnIdleTimeoutMs ?? defaultTurnIdleTimeoutMs;
     }
     /**
-     * 本连接的协议停止通道（design §3.3）。
+     * 本连接的协议停止通道。
      *
      * win32 上「优雅停止」没有可拦截的跨进程 SIGTERM，只能经 agent 自有协议通道
      * 请求对方收摊。子类把这个方法的结果交给 ConnectionManager.stopper，由后者按
@@ -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 超时后照样树杀，等于通道白注册。
      */
@@ -141,7 +141,7 @@ export class ConnectionBasedRunner {
     async stop(_opts) {
         if (!this._isRunning)
             return;
-        // CC-01: 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
+        // 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
         // turn 照常执行。executeTurn 在 setup 完成后检查 stopRequested 补发 cancel。
         this.stopRequested = true;
         this.forceFinish = true;

package/dist/runner/common/jsonl-stream.d.ts

@@ -4,7 +4,7 @@ import type { Readable } from 'node:stream';
 interface JSONLStreamOptions {
     onParseError?: (line: string) => void;
     /**
-     * Pause stdout once `lineQueue` exceeds this depth (P1-4 backpressure).
+     * Pause stdout once `lineQueue` exceeds this depth (backpressure).
      * Default 100 (matches production; tests may pass a smaller value).
      */
     pauseThreshold?: number;
@@ -23,7 +23,7 @@ interface JSONLStreamOptions {
  * - JSON parse errors: when `options.onParseError` is provided, bad lines are
  *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
  *   and the line is skipped.
- * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ * - Optional backpressure: when `pauseThreshold` is set, stdout is
  *   paused once the parsed-line queue exceeds the threshold and resumed once
  *   the consumer drains it back below `resumeThreshold`, bounding memory in
  *   long runs where the producer (agent stdout) outpaces the consumer (card

package/dist/runner/common/jsonl-stream.js

@@ -8,7 +8,7 @@ import { getLogger } from '../../logger/index.js';
  * - JSON parse errors: when `options.onParseError` is provided, bad lines are
  *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
  *   and the line is skipped.
- * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ * - Optional backpressure: when `pauseThreshold` is set, stdout is
  *   paused once the parsed-line queue exceeds the threshold and resumed once
  *   the consumer drains it back below `resumeThreshold`, bounding memory in
  *   long runs where the producer (agent stdout) outpaces the consumer (card
@@ -22,7 +22,7 @@ import { getLogger } from '../../logger/index.js';
  */
 export function createJSONLStream(stdout, options) {
     const lineQueue = [];
-    // P3-1: accumulate partial-line fragments in an array instead of repeatedly
+    // accumulate partial-line fragments in an array instead of repeatedly
     // string-concatenating a growing `partialLine`. A huge single JSON line
     // (large tool_result / text_end) spanning many chunks caused O(n²) copies:
     // each chunk rebuilt `partialLine + text` over the whole accumulated prefix.
@@ -30,7 +30,7 @@ export function createJSONLStream(stdout, options) {
     // and push complete lines; the residual tail stays as array fragments until
     // the next newline or stream end. Net allocation: O(n) instead of O(n²).
     const partialFragments = [];
-    // P2-14: accumulated byte length of partialFragments. Backpressure (above)
+    // accumulated byte length of partialFragments. Backpressure (above)
     // only counts COMPLETE lines in lineQueue; a never-newline stream (malformed
     // output, binary garbage) accumulates fragments without ever completing a
     // line, so pause never fires and memory grows unbounded. Cap the partial
@@ -41,13 +41,13 @@ export function createJSONLStream(stdout, options) {
     const completeLines = [];
     let done = false;
     let resolveNext = null;
-    // P1-4 backpressure thresholds. Default matches production (100).
+    // backpressure thresholds. Default matches production (100).
     const pauseThreshold = options?.pauseThreshold ?? 100;
     // Default low-water mark is half the high-water mark for meaningful hysteresis
     // (avoids per-line pause/resume thrashing when callers don't set it explicitly).
     let resumeThreshold = options?.resumeThreshold ?? Math.max(0, Math.floor(pauseThreshold / 2));
     // Clamp misconfiguration: resumeThreshold > pauseThreshold would resume at queue
-    // high water then immediately re-pause on the next line → thrash (P1-4 review nit).
+    // high water then immediately re-pause on the next line → thrash (nit).
     if (resumeThreshold > pauseThreshold)
         resumeThreshold = pauseThreshold;
     let paused = false;
@@ -58,7 +58,7 @@ export function createJSONLStream(stdout, options) {
         }
     }
     // Flush any trailing partial line and mark the stream finished. Shared by the
-    // 'end'/'close'/'error' handlers so flush logic lives in one place (P1-4 review nit).
+    // 'end'/'close'/'error' handlers so flush logic lives in one place (nit).
     function flushAndFinish() {
         if (partialFragments.length > 0) {
             const trimmed = partialFragments.join('').trim();
@@ -70,7 +70,7 @@ export function createJSONLStream(stdout, options) {
         done = true;
         notify();
     }
-    // P2-14: flush an oversize partial line as a bad line. When partialFragments
+    // flush an oversize partial line as a bad line. When partialFragments
     // exceeds the byte cap, the partial line is treated as malformed (a single
     // JSON line should never reach 10MB) and reported via onParseError rather
     // than accumulated indefinitely. Resets the buffer so a pathological stream
@@ -93,7 +93,7 @@ export function createJSONLStream(stdout, options) {
     }
     // Apply backpressure after pushing new lines: pause stdout when the queue
     // exceeds the high-water mark so the producer stops feeding until the
-    // consumer drains it. P1-4 bounds memory in long runs.
+    // consumer drains it.bounds memory in long runs.
     function maybePause() {
         if (pauseThreshold > 0 && !paused && lineQueue.length > pauseThreshold) {
             paused = true;
@@ -110,7 +110,7 @@ export function createJSONLStream(stdout, options) {
     }
     stdout.on('data', (chunk) => {
         const text = chunk.toString('utf-8');
-        // P3-1: split on newlines. The first segment continues the pending partial
+        // split on newlines. The first segment continues the pending partial
         // line (joined with accumulated fragments — one join per chunk, not per
         // byte); subsequent segments are complete lines. The last segment is the
         // new partial tail (kept as a single fragment).
@@ -119,7 +119,7 @@ export function createJSONLStream(stdout, options) {
             // No newline in this chunk: the whole chunk is a partial fragment.
             partialFragments.push(segments[0]);
             partialBytes += segments[0].length;
-            // P2-14: cap the partial line. A never-newline stream would otherwise
+            // cap the partial line. A never-newline stream would otherwise
             // accumulate fragments without bound (backpressure only counts complete
             // lines). Flush as a bad line once the byte cap is exceeded.
             if (partialBytes > PARTIAL_BYTE_LIMIT) {
@@ -140,7 +140,7 @@ export function createJSONLStream(stdout, options) {
             // Last segment is the new partial tail.
             partialFragments.push(segments[segments.length - 1]);
             partialBytes = segments[segments.length - 1].length;
-            // P2-14: the trailing partial tail can itself exceed the cap if a single
+            // the trailing partial tail can itself exceed the cap if a single
             // chunk is larger than 10MB with no internal newline.
             if (partialBytes > PARTIAL_BYTE_LIMIT) {
                 flushOversizePartial();
@@ -162,7 +162,7 @@ export function createJSONLStream(stdout, options) {
     stdout.on('close', () => {
         flushAndFinish();
     });
-    // P1-4: handle stdout 'error' so the generator terminates instead of
+    // handle stdout 'error' so the generator terminates instead of
     // hanging forever on the `await new Promise` below. Without this, a stdout
     // error (e.g. broken pipe, runner crash) leaves the consumer awaiting a
     // notify that never comes → bridge serial queue blocks permanently. We do

package/dist/runner/common/jsonrpc/client.d.ts

@@ -44,7 +44,7 @@ export declare class JsonRpcClient<InitializeResult = unknown> {
      * Replace the per-run hooks (used by the runner to bridge
      * notifications/server requests into the active turn's translator).
      * Connection-layer hooks (slot cleanup / onConnectionLost) are preserved:
-     * review P2-1 — an overwrite here previously silenced onClose slot cleanup,
+     * an overwrite here previously silenced onClose slot cleanup,
      * leaving dead slots behind after the server process was killed.
      */
     setHooks(hooks: ClientHooks): void;

package/dist/runner/common/jsonrpc/client.js

@@ -61,7 +61,7 @@ export class JsonRpcClient {
      * Replace the per-run hooks (used by the runner to bridge
      * notifications/server requests into the active turn's translator).
      * Connection-layer hooks (slot cleanup / onConnectionLost) are preserved:
-     * review P2-1 — an overwrite here previously silenced onClose slot cleanup,
+     * an overwrite here previously silenced onClose slot cleanup,
      * leaving dead slots behind after the server process was killed.
      */
     setHooks(hooks) {

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,9 +92,9 @@ 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，
+     * 协议停止通道工厂：连接建立后按 pid 登记到 AgentStopperRegistry，
      * 供 Terminator 在**优雅**停止时回调（win32 上没有可拦截的 SIGTERM，只能靠
      * 协议通道让 agent 自己收摊）。返回 undefined = 该协议无通道。
      *
@@ -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).
  *
@@ -34,7 +34,7 @@ export class ConnectionManager {
     /** Callback when a connection is lost — cleared from slot map. */
     onConnectionLost;
     /**
-     * 协议停止通道工厂（design §3.3）：连接建立后按 pid 登记到 AgentStopperRegistry，
+     * 协议停止通道工厂：连接建立后按 pid 登记到 AgentStopperRegistry，
      * 供 Terminator 在**优雅**停止时回调（win32 上没有可拦截的 SIGTERM，只能靠
      * 协议通道让 agent 自己收摊）。返回 undefined = 该协议无通道。
      *
@@ -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/jsonrpc/transport.d.ts

@@ -42,7 +42,7 @@ export declare class JsonlRpcTransport {
         /** 终止器注入（测试用）；默认按平台建实现 */
         terminator?: Terminator;
         /**
-         * 协议停止通道工厂（design §3.3）：spawn 成功后按 pid 建通道并登记到
+         * 协议停止通道工厂：spawn 成功后按 pid 建通道并登记到
          * AgentStopperRegistry，进程退出/关闭时注销。返回 undefined = 无通道。
          */
         stopper?: (pid: number) => AgentStopper | undefined;

package/dist/runner/common/jsonrpc/transport.js

@@ -70,7 +70,7 @@ export class JsonlRpcTransport {
         // agent 是用户自己的可信二进制，provider 认证依赖 API key /
         // 自定义 provider 的 env_key，代理环境依赖 HTTP(S)_PROXY、TMPDIR 等；
         // 任何白名单收窄都会打断认证或网络。调用方 this.env 覆盖 process.env 同名键。
-        // env 覆盖必须大小写不敏感合并（win32 PATH/Path 双键防护，v2 §8.3）
+        // env 覆盖必须大小写不敏感合并（win32 PATH/Path 双键防护）
         const childEnv = mergeProcessEnv(process.env, this.env);
         const proc = spawnProcess(this.binary, this.args, {
             cwd: this.cwd,
@@ -195,7 +195,7 @@ export class JsonlRpcTransport {
         }
         try {
             // 入队后顺序 flush；write() 返回 false（高水位）时暂停直到 drain，
-            // 避免大消息/突发消息在 Node 内部无限缓冲（review P3-8）。
+            // 避免大消息/突发消息在 Node 内部无限缓冲。
             this.writeQueue.push(Buffer.from(JSON.stringify(msg) + '\n', 'utf8'));
             this.flush();
         }

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