@kafca/agentdock 0.1.43 → 0.1.45

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-backend.js

@@ -13,8 +13,8 @@ const local_core_slash_commands_js_1 = require("./local-core-slash-commands.js")
 const local_core_acp_progress_js_1 = require("./local-core-acp-progress.js");
 const index_js_1 = require("../agents/index.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
-const thread_command_service_js_1 = require("../thread/thread-command-service.js");
-const session_command_service_js_1 = require("../thread/session-command-service.js");
+const thread_slash_command_dispatcher_js_1 = require("../thread/thread-slash-command-dispatcher.js");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
     options;
@@ -22,8 +22,7 @@ class LocalCoreAcpBackend {
     turnCoordinator;
     sessionCoordinator;
     responseProcessor;
-    commandService;
-    sessionCommandService;
+    slashCommands;
     constructor(options) {
         this.options = options;
         this.transport = new local_core_acp_transport_js_1.LocalCoreAcpTransport({
@@ -91,25 +90,28 @@ class LocalCoreAcpBackend {
             emitBridge: (event) => this.emitBridgeEvent(event),
             log: options.log,
         });
-        this.commandService = new thread_command_service_js_1.ThreadCommandService({
-            getThreadRow: (threadId) => this.options.store.getThreadRow(threadId),
-            updateThreadAgentMode: (threadId, mode) => this.options.store.updateThreadAgentMode(threadId, mode),
-            updateThreadAgentType: (threadId, agentType) => this.options.store.updateThreadAgentType(threadId, agentType),
-            getLatestRunForThread: (threadId) => this.options.store.getLatestRunForThread(threadId),
-            createAuditEvent: (input) => {
-                this.options.store.createAuditEvent(input);
+        this.slashCommands = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
+            session: {
+                listThreads: (workspaceId) => this.listThreads(workspaceId),
+                getThread: (targetThreadId) => this.getThread(targetThreadId),
+                createThread: (workspaceId, title) => this.createThread(workspaceId, title),
+                renameThread: (targetThreadId, title) => this.renameThread(targetThreadId, title),
+                deleteThread: (targetThreadId) => this.deleteThread(targetThreadId),
+            },
+            thread: {
+                getThreadRow: (threadId) => this.options.store.getThreadRow(threadId),
+                updateThreadAgentMode: (threadId, mode) => this.options.store.updateThreadAgentMode(threadId, mode),
+                updateThreadAgentType: (threadId, agentType) => this.options.store.updateThreadAgentType(threadId, agentType),
+                getLatestRunForThread: (threadId) => this.options.store.getLatestRunForThread(threadId),
+                createAuditEvent: (input) => {
+                    this.options.store.createAuditEvent(input);
+                },
+                getAgentTypes: options.getAgentTypes,
+                setThreadMode: (threadId, mode) => this.sessionCoordinator.setThreadMode(threadId, mode),
+                closeThreadSession: (threadId) => this.sessionCoordinator.closeThreadSession(threadId),
+                interruptRun: (runId) => this.sessionCoordinator.interruptRun(runId),
+                log: options.log,
             },
-            getAgentTypes: options.getAgentTypes,
-            setThreadMode: (threadId, mode) => this.sessionCoordinator.setThreadMode(threadId, mode),
-            closeThreadSession: (threadId) => this.sessionCoordinator.closeThreadSession(threadId),
-            log: options.log,
-        });
-        this.sessionCommandService = new session_command_service_js_1.SessionCommandService({
-            listThreads: (workspaceId) => this.listThreads(workspaceId),
-            getThread: (targetThreadId) => this.getThread(targetThreadId),
-            createThread: (workspaceId, title) => this.createThread(workspaceId, title),
-            renameThread: (targetThreadId, title) => this.renameThread(targetThreadId, title),
-            deleteThread: (targetThreadId) => this.deleteThread(targetThreadId),
         });
         this.responseProcessor = new local_core_acp_response_processor_js_1.LocalCoreAcpResponseProcessor({
             getScheduledDeliveryBinding: (threadId) => {
@@ -173,22 +175,24 @@ class LocalCoreAcpBackend {
                 source: 'user',
             },
         });
-        const sessionCommandResult = await this.sessionCommandService.execute(content, {
-            currentThreadId: threadId,
+        const slashCommandResult = await this.slashCommands.execute({
+            threadId,
             workspaceId: row.workspace_id,
+            content,
+            defaultAgentType: config.agentType,
             defaultTitle: `New thread ${new Date().toLocaleTimeString()}`,
         });
-        if (sessionCommandResult.handled) {
-            const activeThreadEffect = (sessionCommandResult.effects || [])
+        if (slashCommandResult.handled) {
+            const activeThreadEffect = (slashCommandResult.effects || [])
                 .find((effect) => effect.type === 'activate_thread');
-            this.options.store.appendMessage(threadId, 'assistant', sessionCommandResult.displayText, 'final');
+            this.options.store.appendMessage(threadId, 'assistant', slashCommandResult.displayText, 'final');
             this.options.eventBus.emit({
                 type: 'thread.message.accepted',
                 payload: {
                     threadId,
                     workspaceId: row.workspace_id,
                     role: 'assistant',
-                    content: sessionCommandResult.displayText,
+                    content: slashCommandResult.displayText,
                     kind: 'final',
                     source: 'system',
                 },
@@ -207,37 +211,7 @@ class LocalCoreAcpBackend {
             this.emitBridgeEvent({
                 type: 'reply',
                 sessionKey: row.bridge_session_key,
-                content: sessionCommandResult.displayText,
-            });
-            this.emitBridgeEvent({
-                type: 'typing_stop',
-                sessionKey: row.bridge_session_key,
-            });
-            return { runId: '' };
-        }
-        const commandResult = await this.commandService.execute({
-            threadId,
-            workspaceId: row.workspace_id,
-            content,
-            defaultAgentType: config.agentType,
-        });
-        if (commandResult.handled) {
-            this.options.store.appendMessage(threadId, 'assistant', commandResult.displayText, 'final');
-            this.options.eventBus.emit({
-                type: 'thread.message.accepted',
-                payload: {
-                    threadId,
-                    workspaceId: row.workspace_id,
-                    role: 'assistant',
-                    content: commandResult.displayText,
-                    kind: 'final',
-                    source: 'system',
-                },
-            });
-            this.emitBridgeEvent({
-                type: 'reply',
-                sessionKey: row.bridge_session_key,
-                content: commandResult.displayText,
+                content: slashCommandResult.displayText,
             });
             this.emitBridgeEvent({
                 type: 'typing_stop',
@@ -257,6 +231,24 @@ class LocalCoreAcpBackend {
             title: content.trim().slice(0, 80) || row.title || 'Agent task',
             prompt: content,
             status: 'running',
+            metadata: {
+                execution: config.execution || {
+                    mode: config.sandbox?.enabled ? 'sandbox' : 'local',
+                    transport: config.sandbox?.enabled ? `sandbox-${config.sandbox.transport}-stdio-proxy` : 'stdio',
+                },
+                ...(config.sandbox?.enabled
+                    ? {
+                        sandbox: {
+                            provider: config.sandbox.provider,
+                            image: config.sandbox.image,
+                            transport: config.sandbox.transport,
+                            acpPort: config.sandbox.acpPort,
+                            stateScope: config.sandbox.stateScope,
+                            stateMount: config.sandbox.stateMount || null,
+                        },
+                    }
+                    : {}),
+            },
         });
         this.options.eventBus.emit({
             type: 'run.started',
@@ -320,6 +312,12 @@ class LocalCoreAcpBackend {
     async interruptRun(runId) {
         return this.sessionCoordinator.interruptRun(runId);
     }
+    async setThreadMode(threadId, mode) {
+        return this.sessionCoordinator.setThreadMode(threadId, mode);
+    }
+    closeThreadSession(threadId) {
+        this.sessionCoordinator.closeThreadSession(threadId);
+    }
     async runPrompt(threadId, runId, bridgeSessionKey, config, input, options = {}) {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
@@ -333,11 +331,14 @@ class LocalCoreAcpBackend {
         const message = (0, local_core_acp_content_js_1.normalizeThreadMessageInput)(input);
         const content = message.displayText;
         let session = null;
+        const runStartedAt = Date.now();
         try {
             session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config, {
                 permissionMode: options.permissionMode,
                 runtimeEnv: options.runtimeEnv,
+                runId,
             });
+            this.options.log?.(`[acp.run:${runId}] session ready in ${Date.now() - runStartedAt}ms`);
             const priorAssistantFinalMessages = this.options.store
                 .getThread(threadId, [])
                 .messages
@@ -385,8 +386,10 @@ class LocalCoreAcpBackend {
                 messageId: (0, node_crypto_1.randomUUID)(),
                 prompt: message.contentParts,
             }, ACP_PROMPT_TIMEOUT_MS);
+            this.options.log?.(`[acp.run:${runId}] prompt sent in ${Date.now() - runStartedAt}ms`);
             session.promptPromise = promptPromise;
             const result = await promptPromise;
+            this.options.log?.(`[acp.run:${runId}] prompt completed in ${Date.now() - runStartedAt}ms`);
             const currentTurn = session.currentTurn;
             if (!currentTurn || currentTurn.runId !== runId) {
                 return;
@@ -492,13 +495,18 @@ class LocalCoreAcpBackend {
             });
         }
         catch (error) {
-            const errorContent = `Agent error: ${error instanceof Error ? error.message : String(error)}`;
+            const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error, 'internal_error', {
+                threadId,
+                workspaceId: row.workspace_id,
+                runtimeId: config.agentType,
+            });
+            const errorContent = (0, local_core_errors_js_1.formatUserError)(errorInfo);
             this.options.store.updateRun(runId, threadId, 'failed');
             const task = this.options.store.getAgentTaskByRunId(runId);
             if (task) {
                 this.options.store.updateAgentTask(task.taskId, {
                     status: 'failed',
-                    error: error instanceof Error ? error.message : String(error),
+                    error: errorInfo.message,
                 });
             }
             this.options.store.appendMessage(threadId, 'assistant', errorContent, 'final');
@@ -519,7 +527,21 @@ class LocalCoreAcpBackend {
                     runId,
                     threadId,
                     workspaceId: row.workspace_id,
-                    error: error instanceof Error ? error.message : String(error),
+                    error: errorInfo.message,
+                    errorInfo,
+                },
+            });
+            this.options.eventBus.emit({
+                type: 'localcore.error',
+                payload: {
+                    scope: 'acp.run',
+                    errorInfo,
+                    context: {
+                        threadId,
+                        workspaceId: row.workspace_id,
+                        runtimeId: config.agentType,
+                        runId,
+                    },
                 },
             });
             this.emitBridgeEvent({
@@ -544,16 +566,43 @@ class LocalCoreAcpBackend {
             if (session) {
                 session.promptPromise = null;
             }
+            if (config.sandbox?.enabled) {
+                this.sessionCoordinator.releaseThreadSession(threadId, config);
+            }
         }
     }
     handleAgentRequest(session, payload) {
         this.turnCoordinator.handleAgentRequest(session, payload);
     }
     handleAgentNotification(session, payload) {
+        if (session.currentTurn && !session.currentTurn.firstAgentUpdateLogged) {
+            session.currentTurn.firstAgentUpdateLogged = true;
+            this.options.log?.(`[acp.run:${session.currentTurn.runId}] first agent update received`);
+        }
         this.turnCoordinator.handleAgentNotification(session, payload);
     }
     handleTransportSessionClosed(session, error) {
+        const row = this.options.store.getThreadRow(session.threadId);
+        const runtimeId = session.currentTurn?.agentType || row?.agent_type || '';
+        const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error, 'runtime_exited', {
+            threadId: session.threadId,
+            workspaceId: row?.workspace_id || '',
+            runtimeId,
+        });
         this.sessionCoordinator.handleTransportSessionClosed(session, error);
+        this.options.eventBus.emit({
+            type: 'localcore.error',
+            payload: {
+                scope: 'acp.session',
+                errorInfo,
+                context: {
+                    threadId: session.threadId,
+                    workspaceId: row?.workspace_id || '',
+                    runtimeId,
+                    runId: session.currentRunId || '',
+                },
+            },
+        });
     }
     emitBridgeEvent(event) {
         if (event.replyCtx) {

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-session-coordinator.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpSessionCoordinator = void 0;
+exports.buildAgentPath = buildAgentPath;
 const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
 class LocalCoreAcpSessionCoordinator {
     options;
@@ -14,6 +16,7 @@ class LocalCoreAcpSessionCoordinator {
     }
     closeAll() {
         for (const session of this.sessions.values()) {
+            this.clearIdleClose(session);
             this.options.transport.closeSession(session);
         }
         this.sessions.clear();
@@ -23,9 +26,21 @@ class LocalCoreAcpSessionCoordinator {
         if (!session) {
             return;
         }
+        this.clearIdleClose(session);
         this.options.transport.closeSession(session);
         this.sessions.delete(threadId);
     }
+    releaseThreadSession(threadId, config) {
+        if (!config.sandbox?.enabled || config.sandbox.lifecycle === 'per_run' || config.sandbox.stateScope === 'run') {
+            this.closeThreadSession(threadId);
+            return;
+        }
+        const session = this.sessions.get(threadId);
+        if (!session || session.closed) {
+            return;
+        }
+        this.scheduleIdleClose(session, config.sandbox.idleSeconds);
+    }
     async ensureSession(threadId, bridgeSessionKey, config, options = {}) {
         const existing = this.sessions.get(threadId);
         const permissionMode = this.resolveLaunchPermissionMode(threadId, options.permissionMode);
@@ -37,11 +52,15 @@ class LocalCoreAcpSessionCoordinator {
             && existing.launchPermissionMode === permissionMode
             && existing.launchConfigKey === configKey
             && existing.launchRuntimeEnvKey === runtimeEnvKey) {
+            this.clearIdleClose(existing);
+            this.options.log?.(`[acp.session:${threadId}] reuse existing session mode=${config.sandbox?.enabled ? 'sandbox' : 'local'}`);
             return existing;
         }
         if (existing) {
             this.closeThreadSession(threadId);
         }
+        const startedAt = Date.now();
+        this.options.log?.(`[acp.session:${threadId}] spawn mode=${config.sandbox?.enabled ? 'sandbox' : 'local'} transport=${config.execution?.transport || 'stdio'}`);
         const baseEnv = {
             ...process.env,
             ...config.env,
@@ -50,20 +69,21 @@ class LocalCoreAcpSessionCoordinator {
             threadId,
             bridgeSessionKey,
             config,
-            runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || ''), options.runtimeEnv),
+            runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || ''), options.runtimeEnv, options.runId),
         });
         session.launchPermissionMode = permissionMode;
         session.launchConfigKey = configKey;
         session.launchRuntimeEnvKey = runtimeEnvKey;
         this.sessions.set(threadId, session);
         await this.options.transport.initializeSession(session);
+        this.options.log?.(`[acp.session:${threadId}] initialize done in ${Date.now() - startedAt}ms`);
         const row = this.options.store.getThreadRow(threadId);
         if (row?.acp_session_id && row.acp_supports_load && session.supportsLoad) {
             try {
                 session.loadReplayMode = true;
                 await this.options.transport.request(session, 'session/load', {
                     sessionId: row.acp_session_id,
-                    cwd: config.workDir,
+                    cwd: acpSessionCwd(config),
                     mcpServers: [],
                 }, 30000);
                 session.sessionId = row.acp_session_id;
@@ -78,7 +98,7 @@ class LocalCoreAcpSessionCoordinator {
         if (!session.sessionId) {
             try {
                 const created = await this.options.transport.request(session, 'session/new', {
-                    cwd: config.workDir,
+                    cwd: acpSessionCwd(config),
                     mcpServers: [],
                     _meta: this.buildSessionMeta(threadId, permissionMode),
                 }, 30000);
@@ -87,12 +107,14 @@ class LocalCoreAcpSessionCoordinator {
                     throw new Error('ACP session/new did not return a sessionId');
                 }
                 this.options.store.updateThreadSession(threadId, session.sessionId, session.supportsLoad);
+                this.options.log?.(`[acp.session:${threadId}] session/new done in ${Date.now() - startedAt}ms`);
             }
             catch (error) {
                 this.closeThreadSession(threadId);
                 throw error;
             }
         }
+        this.options.log?.(`[acp.session:${threadId}] ready in ${Date.now() - startedAt}ms`);
         return session;
     }
     async setThreadMode(threadId, mode) {
@@ -152,6 +174,7 @@ class LocalCoreAcpSessionCoordinator {
             return;
         }
         const activeRunId = session.currentRunId;
+        this.clearIdleClose(session);
         this.options.transport.closeSessionWithError(session, error);
         if (activeRunId) {
             this.options.store.updateRun(activeRunId, session.threadId, 'failed');
@@ -166,13 +189,31 @@ class LocalCoreAcpSessionCoordinator {
             this.sessions.delete(session.threadId);
         }
     }
+    scheduleIdleClose(session, idleSeconds) {
+        this.clearIdleClose(session);
+        const seconds = Number.isFinite(idleSeconds) && idleSeconds > 0 ? idleSeconds : 900;
+        this.options.log?.(`[acp.session:${session.threadId}] keep sandbox session warm for ${seconds}s`);
+        session.idleCloseTimer = setTimeout(() => {
+            if (this.sessions.get(session.threadId) === session && !session.closed && !session.currentRunId) {
+                this.options.log?.(`[acp.session:${session.threadId}] idle timeout reached; closing sandbox session`);
+                this.closeThreadSession(session.threadId);
+            }
+        }, seconds * 1000);
+        session.idleCloseTimer.unref?.();
+    }
+    clearIdleClose(session) {
+        if (session.idleCloseTimer) {
+            clearTimeout(session.idleCloseTimer);
+            session.idleCloseTimer = undefined;
+        }
+    }
     buildRuntimeEnvKey(runtimeEnv = {}) {
         return Object.keys(runtimeEnv)
             .sort()
             .map((key) => `${key}=${runtimeEnv[key]}`)
             .join('\n');
     }
-    buildAgentRuntimeEnv(threadId, existingPath, runtimeEnv = {}) {
+    buildAgentRuntimeEnv(threadId, existingPath, runtimeEnv = {}, runId = '') {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
             return {};
@@ -182,6 +223,7 @@ class LocalCoreAcpSessionCoordinator {
             LOCAL_AI_CORE_BASE: this.options.localCoreBase || 'http://127.0.0.1:9831/api/local/v1',
             LOCAL_AI_WORKSPACE_ID: row.workspace_id,
             LOCAL_AI_THREAD_ID: threadId,
+            ...(runId ? { AGENTDOCK_SANDBOX_RUN_ID: runId } : {}),
         };
         const workspace = this.options.store.getWorkspaceRegistryEntry(row.workspace_id);
         if (workspace?.path) {
@@ -198,9 +240,10 @@ class LocalCoreAcpSessionCoordinator {
             env.LOCAL_AI_PLATFORM_USER_ID = binding.platform_user_id;
         }
         if (this.options.cliBinDir) {
-            env.PATH = existingPath
-                ? `${this.options.cliBinDir}${node_path_1.delimiter}${existingPath}`
-                : this.options.cliBinDir;
+            env.PATH = buildAgentPath(existingPath, this.options.cliBinDir);
+        }
+        else {
+            env.PATH = buildAgentPath(existingPath);
         }
         return {
             ...env,
@@ -215,6 +258,8 @@ class LocalCoreAcpSessionCoordinator {
             args: config.args || [],
             env: config.env || {},
             model: config.model || '',
+            execution: config.execution || null,
+            sandbox: config.sandbox || null,
         });
     }
     resolveLaunchPermissionMode(threadId, permissionModeOverride = '') {
@@ -241,3 +286,31 @@ class LocalCoreAcpSessionCoordinator {
     }
 }
 exports.LocalCoreAcpSessionCoordinator = LocalCoreAcpSessionCoordinator;
+function acpSessionCwd(config) {
+    return config.sandbox?.enabled ? config.sandbox.workspaceMountPath : config.workDir;
+}
+function buildAgentPath(existingPath, cliBinDir) {
+    const entries = [
+        cliBinDir,
+        ...userBinDirs(),
+        ...String(existingPath || '').split(node_path_1.delimiter),
+    ];
+    const seen = new Set();
+    return entries
+        .map((entry) => String(entry || '').trim())
+        .filter((entry) => {
+        if (!entry || seen.has(entry)) {
+            return false;
+        }
+        seen.add(entry);
+        return true;
+    })
+        .join(node_path_1.delimiter);
+}
+function userBinDirs() {
+    if (process.platform === 'win32') {
+        return [];
+    }
+    const home = process.env.HOME || (0, node_os_1.homedir)();
+    return home ? [`${home}/.local/bin`, `${home}/bin`] : [];
+}

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-transport.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpTransport = void 0;
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 class LocalCoreAcpTransport {
     options;
     constructor(options) {
@@ -12,8 +14,9 @@ class LocalCoreAcpTransport {
             ...process.env,
             ...input.config.env,
         };
+        const cwd = resolveTransportCwd(input.config);
         const child = (0, node_child_process_1.spawn)(input.config.command, input.config.args, {
-            cwd: input.config.workDir,
+            cwd,
             env: {
                 ...baseEnv,
                 ...input.runtimeEnv,
@@ -51,7 +54,37 @@ class LocalCoreAcpTransport {
             this.handlePipeFailure(session, error);
         });
         child.on('exit', (code, signal) => {
-            this.options.onSessionClosed(session, new Error(`ACP agent exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}`));
+            if (session.closed) {
+                return;
+            }
+            this.options.onSessionClosed(session, new local_core_errors_js_1.LocalCoreError('runtime_exited', `ACP agent exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}`, {
+                details: {
+                    code: code ?? 'unknown',
+                    signal: signal || '',
+                    threadId: input.threadId,
+                    runtimeId: input.config.agentType,
+                },
+            }));
+        });
+        child.on('error', (error) => {
+            this.options.onSessionClosed(session, error.code === 'ENOENT'
+                ? new local_core_errors_js_1.LocalCoreError('runtime_not_found', `ACP agent command not found: ${input.config.command}`, {
+                    details: {
+                        command: input.config.command,
+                        cwd,
+                        threadId: input.threadId,
+                        runtimeId: input.config.agentType,
+                    },
+                })
+                : new local_core_errors_js_1.LocalCoreError('runtime_start_failed', `ACP agent failed to start: ${error.message}`, {
+                    cause: error.code,
+                    details: {
+                        command: input.config.command,
+                        cwd,
+                        threadId: input.threadId,
+                        runtimeId: input.config.agentType,
+                    },
+                }));
         });
         return session;
     }
@@ -79,7 +112,14 @@ class LocalCoreAcpTransport {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 session.pending.delete(id);
-                reject(new Error(`Timed out waiting for ACP ${method} after ${timeoutMs}ms`));
+                reject(new local_core_errors_js_1.LocalCoreError('runtime_protocol_timeout', `Timed out waiting for ACP ${method} after ${timeoutMs}ms`, {
+                    details: {
+                        method,
+                        timeoutMs,
+                        threadId: session.threadId,
+                        runtimeId: session.currentTurn?.agentType || '',
+                    },
+                }));
             }, timeoutMs);
             session.pending.set(id, {
                 resolve: (value) => {
@@ -175,7 +215,15 @@ class LocalCoreAcpTransport {
                 }
                 session.pending.delete(payload.id);
                 if (payload.error) {
-                    pending.reject(new Error(payload.error.message || `ACP request failed: ${payload.id}`));
+                    pending.reject(new local_core_errors_js_1.LocalCoreError(errorCodeForAcpError(payload.error), payload.error.message || `ACP request failed: ${payload.id}`, {
+                        details: {
+                            payloadId: payload.id,
+                            errorCode: payload.error.code,
+                            errorData: payload.error.data,
+                            threadId: session.threadId,
+                            runtimeId: session.currentTurn?.agentType || '',
+                        },
+                    }));
                 }
                 else {
                     pending.resolve(payload.result);
@@ -184,9 +232,34 @@ class LocalCoreAcpTransport {
         }
     }
     handlePipeFailure(session, error) {
+        if (session.closed) {
+            return;
+        }
         const message = error instanceof Error ? error.message : String(error);
         this.options.log?.(`[localcore-acp:${session.threadId}] stdin failure: ${message}`);
-        this.options.onSessionClosed(session, new Error(message));
+        this.options.onSessionClosed(session, new local_core_errors_js_1.LocalCoreError('runtime_protocol_error', message, {
+            details: {
+                threadId: session.threadId,
+                runtimeId: session.currentTurn?.agentType || '',
+            },
+        }));
     }
 }
 exports.LocalCoreAcpTransport = LocalCoreAcpTransport;
+function resolveTransportCwd(config) {
+    if (config.sandbox?.enabled) {
+        const proxyCwd = String(config.sandbox.proxyCwd || '').trim();
+        if (proxyCwd && (0, node_fs_1.existsSync)(proxyCwd)) {
+            return proxyCwd;
+        }
+        return process.cwd();
+    }
+    return config.workDir;
+}
+function errorCodeForAcpError(error) {
+    const message = String(error?.message || '').toLowerCase();
+    if (message.includes('authentication required') || message.includes('api key') || message.includes('oauth')) {
+        return 'provider_auth_failed';
+    }
+    return 'runtime_protocol_error';
+}