lark-remote 0.4.4 → 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/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.
      */

package/dist/runner/common/spawning-runner.js

@@ -2,7 +2,7 @@ import { spawnProcess, isWindowsCommandNotFoundLine, useDetachedProcessGroup, }
 import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs';
-import { silentlyUnlink } from '../../common/fs.js';
+import { bestEffortUnlink } from '../../common/fs.js';
 import { getLogger } from '../../logger/index.js';
 import { binaryName, verifyPidIdentityVerdictSync } from '../../platform/identity.js';
 import { createTerminator } from '../../platform/terminator.js';
@@ -120,7 +120,7 @@ export class SpawningRunner {
         this.logTag = opts.logTag ?? 'spawning-runner';
         this.agent = opts.agent;
         const pidDir = opts.pidDir ?? path.join(os.homedir(), '.lark-remote');
-        const workspaceSuffix = `-${opts.workspace.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        const workspaceSuffix = `-${opts.cwd.replace(/[^a-zA-Z0-9]/g, '_')}`;
         const pidFilePrefix = opts.pidFilePrefix ?? 'spawning';
         this.pidFilePath = path.join(pidDir, `${pidFilePrefix}${workspaceSuffix}.pid`);
         this.terminator =
@@ -158,7 +158,7 @@ export 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.
      */
@@ -298,7 +298,7 @@ export class SpawningRunner {
         // （immediate 路径不查表，但一并注销同样正确——进程已进入终止流程）。
         this.unregisterStopper();
         this.currentProcess = null;
-        silentlyUnlink(this.pidFilePath);
+        bestEffortUnlink(this.pidFilePath);
         getLogger().debug(`[${this.logTag}] cleaned pid file ${this.pidFilePath}`);
     }
     /**
@@ -324,7 +324,7 @@ export class SpawningRunner {
             const pidStr = fs.readFileSync(this.pidFilePath, 'utf-8').trim();
             const pid = Number(pidStr);
             if (isNaN(pid) || pid <= 0) {
-                silentlyUnlink(this.pidFilePath);
+                bestEffortUnlink(this.pidFilePath);
                 return;
             }
             const expectedBinary = binaryName(this.binary);
@@ -339,7 +339,7 @@ export class SpawningRunner {
             if (verdict !== 'match') {
                 getLogger().warn(`[${this.logTag}] killOrphan: pid ${pid} not confirmed as ${expectedBinary} ` +
                     `(${verdict}), skipping kill`);
-                silentlyUnlink(this.pidFilePath);
+                bestEffortUnlink(this.pidFilePath);
                 return;
             }
             // 身份匹配：杀整个进程组（detached:true 下 agent 是组长），与
@@ -351,7 +351,7 @@ export class SpawningRunner {
             catch {
                 // process may have exited
             }
-            silentlyUnlink(this.pidFilePath);
+            bestEffortUnlink(this.pidFilePath);
         }
         catch {
             // ignore
@@ -401,7 +401,7 @@ export class SpawningRunner {
             catch { }
         }
         this.unregisterStopper();
-        silentlyUnlink(this.pidFilePath);
+        bestEffortUnlink(this.pidFilePath);
     }
 }
 //# sourceMappingURL=spawning-runner.js.map

package/dist/runner/common/{runner-utils.d.ts → synthetic-events.d.ts}

@@ -12,10 +12,10 @@ import type { AgentEvent } from '../types.js';
  */
 export declare function syntheticInitEvent(sessionId?: string): AgentEvent;
 /**
- * Build a standardized auth/error result event for yield.
+ * Build a standardized setup-failure result event for yield.
  *
- * Used when initialization or request sending fails (e.g. not logged in,
- * session creation failed). Produces a
+ * Used when setup fails before a turn can run — process spawn errors
+ * (e.g. ENOENT), not-logged-in, or session creation failure. Produces a
  * `result`/`error` event so the bridge can render a card instead of crashing.
  */
-export declare function authErrorEvent(errorMessage: string, sessionId?: string): AgentEvent;
+export declare function setupErrorEvent(errorMessage: string, sessionId?: string): AgentEvent;

package/dist/runner/common/{runner-utils.js → synthetic-events.js}

@@ -20,13 +20,13 @@ export function syntheticInitEvent(sessionId = '') {
     };
 }
 /**
- * Build a standardized auth/error result event for yield.
+ * Build a standardized setup-failure result event for yield.
  *
- * Used when initialization or request sending fails (e.g. not logged in,
- * session creation failed). Produces a
+ * Used when setup fails before a turn can run — process spawn errors
+ * (e.g. ENOENT), not-logged-in, or session creation failure. Produces a
  * `result`/`error` event so the bridge can render a card instead of crashing.
  */
-export function authErrorEvent(errorMessage, sessionId = '') {
+export function setupErrorEvent(errorMessage, sessionId = '') {
     return {
         type: 'result',
         subtype: 'error',
@@ -35,4 +35,4 @@ export function authErrorEvent(errorMessage, sessionId = '') {
         timestamp: new Date().toISOString(),
     };
 }
-//# sourceMappingURL=runner-utils.js.map
+//# sourceMappingURL=synthetic-events.js.map

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

@@ -86,7 +86,7 @@ export declare class DshClient {
      * `session.history` to fill the gap (dedup by seq). Terminates on turn/end
      * or `signal` abort.
      */
-    sessionEvents(sessionId: string, cwd: string, signal: AbortSignal, initialSeq?: number): AsyncGenerator<DshStreamItem>;
+    sessionEvents(sessionId: string, signal: AbortSignal, initialSeq?: number): AsyncGenerator<DshStreamItem>;
     /** Extract TokenUsage from an assistant/message data payload (absent → undefined). */
     static usageOf(data: Record<string, unknown>): DshTokenUsage | undefined;
 }

package/dist/runner/dsh/client.js

@@ -320,7 +320,7 @@ export class DshClient {
      * `session.history` to fill the gap (dedup by seq). Terminates on turn/end
      * or `signal` abort.
      */
-    async *sessionEvents(sessionId, cwd, signal, initialSeq = -1) {
+    async *sessionEvents(sessionId, signal, initialSeq = -1) {
         const state = { lastSeq: initialSeq };
         // Initial baseline: before opening the first live mux subscription, replay
         // history once so events produced between prompt-accept and the mux opening

package/dist/runner/dsh/runner.js

@@ -135,7 +135,7 @@ export class DshRunner {
                 });
                 const translator = new DshTranslator();
                 try {
-                    for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
+                    for await (const item of this.client.sessionEvents(sessionId, abort.signal, prePromptSeq)) {
                         if (abort.signal.aborted)
                             break;
                         if (item.kind === 'approval') {

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

@@ -21,7 +21,7 @@ import type { AgentKind, AgentSessionReader, AgentStatusInfo, SpawnOptions } fro
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { KimiAcpTranslator } from './translator.js';
 import { type SessionPromptResult } from '../../common/acp/protocol-types.js';
-import { type AcpPendingApproval } from '../../common/acp/protocol-helpers.js';
+import { type AcpPendingApproval } from '../../common/acp/acp-approval.js';
 import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
 export interface KimiAcpRunnerOptions {
     kind: AgentKind;

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

@@ -23,7 +23,7 @@ import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
 import { NotificationMethod, RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
-import { KIMI_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/protocol-helpers.js';
+import { KIMI_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/acp-approval.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';

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

@@ -27,7 +27,7 @@
  */
 import { makeQuestionApprovalEvent } from '../../question-common.js';
 import { ServerRequestMethod, } from '../../common/acp/protocol-types.js';
-import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/protocol-helpers.js';
+import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/acp-approval.js';
 import { getLogger } from '../../../logger/index.js';
 import { BaseAcpTranslator } from '../../common/acp/base-translator.js';
 /**

package/dist/runner/opencode/acp/runner.d.ts

@@ -23,7 +23,7 @@ import type { AgentKind, AgentSessionReader, AgentStatusInfo } from '../../types
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { OpencodeAcpTranslator } from './translator.js';
 import { type SessionNewResult, type SessionResumeResult, type SessionPromptResult } from '../../common/acp/protocol-types.js';
-import { type AcpPendingApproval } from '../../common/acp/protocol-helpers.js';
+import { type AcpPendingApproval } from '../../common/acp/acp-approval.js';
 import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
 export interface OpencodeAcpRunnerOptions {
     kind: AgentKind;
@@ -34,7 +34,7 @@ export interface OpencodeAcpRunnerOptions {
     env?: Record<string, string | undefined>;
     /** Args to spawn the ACP server with. Defaults to `['acp']`. Note: no
      *  explicit `--cwd` — opencode acp defaults --cwd to the process cwd, which
-     *  the transport already sets to the workspace (cli/cmd/acp.ts:13-17). */
+     *  the transport already sets to the cwd (cli/cmd/acp.ts:13-17). */
     acpArgs?: string[];
     /** Request timeout in milliseconds. */
     requestTimeoutMs?: number;

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

@@ -22,7 +22,7 @@
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { OpencodeAcpTranslator } from './translator.js';
 import { RpcErrorCode, } from '../../common/acp/protocol-types.js';
-import { OPENCODE_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/protocol-helpers.js';
+import { OPENCODE_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/acp-approval.js';
 import { getLogger } from '../../../logger/index.js';
 import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
 import { OpencodeLogErrorMonitor, resolveOpencodeLogPath } from './error-monitor.js';

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

@@ -24,7 +24,7 @@
  *   prompt other stopReason/error  → result error
  *   session/request_permission     → approval_requested (optionId echo)
  */
-import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/protocol-helpers.js';
+import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/acp-approval.js';
 import { getLogger } from '../../../logger/index.js';
 import { BaseAcpTranslator } from '../../common/acp/base-translator.js';
 // =============================================================================

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

@@ -30,7 +30,7 @@ export interface PiRpcRunnerOptions {
     thinking?: string;
     /** Tool allowlist. */
     tools?: string[];
-    workspace: string;
+    cwd: string;
     sessionReader: AgentSessionReader;
     /** Path to the pi binary. Defaults to `pi`. */
     binary?: string;

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

@@ -25,7 +25,6 @@ export declare class PiRpcTranslator {
     private currentContentIndex;
     private sessionId;
     private operationKind;
-    private currentTurnId;
     private accInput;
     private accOutput;
     private accCacheRead;

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

@@ -15,7 +15,6 @@ export class PiRpcTranslator {
     currentContentIndex = -1;
     sessionId = '';
     operationKind = 'turn';
-    currentTurnId = '';
     // ccusage-aligned usage accumulation (per-message, summed across the turn).
     accInput = 0;
     accOutput = 0;
@@ -134,7 +133,6 @@ export class PiRpcTranslator {
     /** Self-produced turn_started (no wire equivalent). */
     produceTurnStarted(sessionId, turnId) {
         this.sessionId = sessionId;
-        this.currentTurnId = turnId;
         return {
             type: 'turn_started',
             threadId: sessionId,