@bbigbang/agent-node 0.1.0

package/dist/main.js

@@ -0,0 +1,1659 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import fs from 'node:fs';
+import { openDb, migrate, log, WorkspaceLockManager } from '@bbigbang/runtime-acp';
+import { BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL, BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL, BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL, } from '@bbigbang/protocol';
+import { loadConfig } from './config.js';
+import { CoreConnection } from './connection.js';
+import { Executor } from './executor.js';
+import { ensureNativeSkillMounts } from './nativeSkillMounts.js';
+import { CodexTranscriptFsError, listCodexTranscriptFiles, readCodexTranscriptFile, } from './codexTranscriptFs.js';
+import { ClaudeTranscriptFsError, listClaudeTranscriptFiles, readClaudeTranscriptFile, } from './claudeTranscriptFs.js';
+import { listWorkspaceDirectory, createExactPathReadStream, createWorkspaceDirectoryArchive, deleteWorkspaceFile, deleteWorkspacePath, extractWorkspaceDirectoryArchive, readExactPath, readWorkspaceFile, resetWorkspaceDirectory, statExactPathRawStream, suggestDirectoryPaths, writeWorkspaceFile, WorkspaceFsError, } from './workspaceFs.js';
+import { applyLibraryMirror, snapshotLibraryMirror } from './libraryMirror.js';
+import { deleteLibraryAuthorityPath, renameLibraryAuthorityPath } from './libraryAuthorityFs.js';
+import { listSkills, readSkillFile } from './skillFs.js';
+import { TerminalManager, TerminalManagerError } from './terminalManager.js';
+import { inspectWorkspace, WorkspaceInspectError } from './workspaceInspect.js';
+import { getWorkspaceGitDiff, getWorkspaceGitStatus, runWorkspaceGitAction, WorkspaceGitError } from './workspaceGit.js';
+import { CodexAppServerRpc } from './codexAppServerRpc.js';
+import { runCodexConversationSummary } from './codexConversationSummarizer.js';
+import { inspectDroidMissionContinuation, runDroidMission } from './droidMissionRunner.js';
+import { runNativeMission } from './nativeMissionRunner.js';
+import { NativeMissionAgentExecutor } from './nativeMissionAgentDispatch.js';
+import { fetchLoopbackHttpText, proxyWorkspaceServiceHttp } from './panelHttpFetch.js';
+function isRecoverableRuntimeStreamError(error) {
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code ?? '')
+        : '';
+    const message = String(error?.message ?? error);
+    return code === 'EPIPE'
+        || code === 'ERR_STREAM_DESTROYED'
+        || message.includes('write EPIPE')
+        || message.includes('write after end')
+        || message.includes('Cannot call write after a stream was destroyed');
+}
+function resolvePanelApiJsonlAuthHeaders(profiles, profileName) {
+    const normalizedProfileName = profileName?.trim();
+    if (!normalizedProfileName)
+        return undefined;
+    const headers = profiles[normalizedProfileName];
+    if (!headers) {
+        throw new WorkspaceFsError('invalid_request', `Unknown api_jsonl auth profile "${normalizedProfileName}".`);
+    }
+    return headers;
+}
+async function main() {
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        console.log('Usage: bigbang-node');
+        return;
+    }
+    const config = loadConfig();
+    for (const unavailableDriver of config.unavailableRuntimeDrivers) {
+        log.warn('[agent-node] runtime driver unavailable; omitting from advertised capabilities', unavailableDriver);
+    }
+    // Ensure DB directory exists
+    fs.mkdirSync(path.dirname(config.dbPath), { recursive: true });
+    const db = openDb(config.dbPath);
+    migrate(db);
+    const workspaceLockManager = new WorkspaceLockManager();
+    const terminalManager = new TerminalManager();
+    const codexAppServerRpc = new CodexAppServerRpc({ config });
+    const terminalBackendReason = terminalManager.getBackendUnavailableReason();
+    if (terminalBackendReason) {
+        log.warn('[agent-node] terminal backend unavailable', { reason: terminalBackendReason });
+    }
+    let executor;
+    let connection;
+    const buildRuntimeSnapshot = () => ({
+        workspaceRoot: config.workspaceRoot,
+        terminalBackendAvailable: terminalManager.isBackendAvailable(),
+        runtimeDrivers: config.runtimeDrivers.map((driver) => ({
+            agentType: driver.agentType,
+            command: driver.command,
+            args: [...driver.args],
+            supportsResume: driver.supportsResume,
+            supportsPushNotifications: driver.supportsPushNotifications,
+            capabilities: [...driver.capabilities],
+            nativeMemoryBackend: driver.nativeMemoryBackend,
+            supportsClaudeSessionControls: driver.agentType === 'claude_sdk',
+        })),
+        capabilities: {
+            envProfile: process.env.BIGBANG_NODE_ENV_PROFILE?.trim() || null,
+            agentSurfaceMode: config.agentSurfaceMode,
+            bigbangCliAvailable: config.bigbangCliAvailable,
+            builtinSkillRoots: [
+                BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL,
+                BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL,
+                BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL,
+            ],
+            panelApiJsonlAllowedOrigins: config.panelApiJsonlAllowedOrigins,
+            panelApiJsonlAllowedUrlPrefixes: config.panelApiJsonlAllowedUrlPrefixes,
+            panelApiJsonlAuthProfiles: Object.keys(config.panelApiJsonlAuthProfiles),
+            workspaceRpc: true,
+            workspaceInspect: true,
+            workspaceGit: true,
+            terminals: terminalManager.isBackendAvailable(),
+            skills: true,
+            codexAppServerRpc: config.agentTypes.includes('codex_app_server'),
+            codexTranscripts: true,
+            claudeTranscripts: true,
+            claudeControls: true,
+            nativeMissionWorker: true,
+        },
+    });
+    const publishHostSnapshot = () => {
+        if (!executor || !connection)
+            return;
+        connection.send({
+            type: 'node.hosts.snapshot',
+            nodeId: config.nodeId,
+            generatedAt: Date.now(),
+            hosts: executor.listHostSnapshots(),
+        });
+    };
+    const publishRuntimeSnapshot = () => {
+        if (!connection)
+            return;
+        connection.send({
+            type: 'node.runtime.snapshot',
+            nodeId: config.nodeId,
+            processInstanceId: config.processInstanceId,
+            generatedAt: Date.now(),
+            runtime: buildRuntimeSnapshot(),
+        });
+    };
+    terminalManager.onOutput(({ terminalId, data }) => {
+        connection.send({
+            type: 'terminal.output.event',
+            terminalId,
+            data,
+        });
+    });
+    terminalManager.onExit(({ terminalId, exitCode, signal }) => {
+        connection.send({
+            type: 'terminal.exit.event',
+            terminalId,
+            exitCode,
+            signal,
+        });
+    });
+    const activeNativeWorkers = new Map();
+    const pendingNativeCancellations = new Set();
+    let nativeAgentExecutor = null;
+    const handleMessage = (msg) => {
+        void (async () => {
+            switch (msg.type) {
+                case 'node.ack':
+                    log.info(`[agent-node] registered with core as ${msg.nodeId}`);
+                    executor.resumePendingDispatches();
+                    publishHostSnapshot();
+                    publishRuntimeSnapshot();
+                    break;
+                case 'run.dispatch':
+                    executor.dispatch(msg).catch((err) => {
+                        log.warn('[agent-node] dispatch error', err);
+                    });
+                    break;
+                case 'run.cancel':
+                    executor.cancelRun(msg.runId).then((handled) => {
+                        if (!handled) {
+                            log.warn('[agent-node] run.cancel had no active runtime', msg.runId);
+                        }
+                    }).catch((err) => {
+                        log.warn('[agent-node] run.cancel error', err);
+                    });
+                    break;
+                case 'run.steer':
+                    executor.steerRun(msg.runId, msg.prompt, msg.attachments).then((handled) => {
+                        if (!handled) {
+                            log.warn('[agent-node] run.steer had no active steerable runtime', msg.runId);
+                        }
+                        connection.send({
+                            type: 'run.event',
+                            runId: msg.runId,
+                            conversationId: msg.conversationId,
+                            event: {
+                                type: 'run.steer.result',
+                                requestId: msg.requestId,
+                                runId: msg.runId,
+                                ok: handled,
+                                createdAt: Date.now(),
+                                ...(!handled ? { error: 'Active runtime turn is not steerable.' } : {}),
+                            },
+                        });
+                        connection.send({
+                            type: 'run.steer.result',
+                            requestId: msg.requestId,
+                            runId: msg.runId,
+                            conversationId: msg.conversationId,
+                            ok: handled,
+                            ...(!handled ? { error: 'Active runtime turn is not steerable.' } : {}),
+                        });
+                        if (handled && msg.delivery) {
+                            connection.send({
+                                type: 'run.delivery.ack',
+                                deliveryId: msg.delivery.deliveryId,
+                                roundId: msg.delivery.roundId,
+                                runId: msg.runId,
+                                conversationId: msg.conversationId,
+                                ackedThroughSeq: msg.delivery.ackedThroughSeq,
+                                mode: 'steer',
+                            });
+                        }
+                    }).catch((err) => {
+                        const message = String(err?.message ?? err);
+                        log.warn('[agent-node] run.steer error', err);
+                        connection.send({
+                            type: 'run.event',
+                            runId: msg.runId,
+                            conversationId: msg.conversationId,
+                            event: {
+                                type: 'run.steer.result',
+                                requestId: msg.requestId,
+                                runId: msg.runId,
+                                ok: false,
+                                error: message,
+                                createdAt: Date.now(),
+                            },
+                        });
+                        connection.send({
+                            type: 'run.steer.result',
+                            requestId: msg.requestId,
+                            runId: msg.runId,
+                            conversationId: msg.conversationId,
+                            ok: false,
+                            error: message,
+                        });
+                    });
+                    break;
+                case 'permission.response':
+                    executor.handlePermissionResponse(msg.requestId, msg.decision, msg.selectedActionId, msg.responseText, msg.answers).then((handled) => {
+                        if (!handled) {
+                            log.warn('[agent-node] permission.response had no pending request', msg.requestId);
+                        }
+                    }).catch((err) => {
+                        log.warn('[agent-node] permission.response error', err);
+                    });
+                    break;
+                case 'solo.run.dispatch':
+                    executor.handleSoloDispatch(msg).catch((err) => {
+                        log.warn('[agent-node] solo.run.dispatch error', err);
+                    });
+                    break;
+                case 'solo.cancel':
+                    executor.handleSoloCancel(msg).catch((err) => {
+                        log.warn('[agent-node] solo.cancel error', err);
+                    });
+                    break;
+                case 'solo.close':
+                    executor.handleSoloClose(msg).catch((err) => {
+                        log.warn('[agent-node] solo.close error', err);
+                    });
+                    break;
+                case 'solo.steer':
+                    executor.handleSoloSteer(msg).then((handled) => {
+                        if (!handled) {
+                            log.warn('[agent-node] solo.steer had no active solo runtime', { soloSessionId: msg.soloSessionId });
+                        }
+                    }).catch((err) => {
+                        log.warn('[agent-node] solo.steer error', err);
+                    });
+                    break;
+                case 'solo.permission.response':
+                    executor.handleSoloPermissionResponse(msg).then((handled) => {
+                        if (!handled) {
+                            log.warn('[agent-node] solo.permission.response had no pending request', { soloSessionId: msg.soloSessionId });
+                        }
+                    }).catch((err) => {
+                        log.warn('[agent-node] solo.permission.response error', err);
+                    });
+                    break;
+                case 'mission.run.request':
+                    try {
+                        if (msg.runtimeProvider === 'bigbang_native') {
+                            const wasAlreadyCancelled = pendingNativeCancellations.has(msg.requestId);
+                            runNativeMission(msg, (outbound) => connection.send(outbound), {
+                                onHostCreated: (host) => {
+                                    activeNativeWorkers.set(msg.requestId, host);
+                                    // If a cancellation raced ahead of host creation, honour it
+                                    // immediately so the worker does not start running.
+                                    if (pendingNativeCancellations.has(msg.requestId)) {
+                                        host.cancel();
+                                        pendingNativeCancellations.delete(msg.requestId);
+                                    }
+                                },
+                                onHostExit: () => {
+                                    activeNativeWorkers.delete(msg.requestId);
+                                    pendingNativeCancellations.delete(msg.requestId);
+                                },
+                                onDispatchCreated: (dispatch) => {
+                                    activeNativeWorkers.set(msg.requestId, dispatch);
+                                    // If a cancellation raced ahead of dispatch creation, honour it
+                                    // immediately so the executor run does not start.
+                                    if (pendingNativeCancellations.has(msg.requestId)) {
+                                        dispatch.cancel();
+                                        pendingNativeCancellations.delete(msg.requestId);
+                                    }
+                                },
+                                onDispatchFinished: () => {
+                                    activeNativeWorkers.delete(msg.requestId);
+                                    pendingNativeCancellations.delete(msg.requestId);
+                                },
+                            }, nativeAgentExecutor ?? undefined);
+                            if (wasAlreadyCancelled) {
+                                pendingNativeCancellations.delete(msg.requestId);
+                            }
+                        }
+                        else {
+                            runDroidMission(msg, (outbound) => connection.send(outbound));
+                        }
+                    }
+                    catch (error) {
+                        activeNativeWorkers.delete(msg.requestId);
+                        pendingNativeCancellations.delete(msg.requestId);
+                        connection.send({
+                            type: 'mission.run.end',
+                            requestId: msg.requestId,
+                            missionId: msg.missionId,
+                            missionDir: msg.missionDir,
+                            error: String(error.message ?? error),
+                        });
+                    }
+                    break;
+                case 'mission.run.cancel': {
+                    if (msg.runtimeProvider === 'bigbang_native') {
+                        const active = activeNativeWorkers.get(msg.requestId);
+                        if (active) {
+                            active.cancel();
+                            pendingNativeCancellations.delete(msg.requestId);
+                            log.info('[agent-node] native mission worker cancelled', {
+                                requestId: msg.requestId,
+                                missionId: msg.missionId,
+                                featureId: msg.featureId,
+                            });
+                        }
+                        else {
+                            // The worker may not have been created yet if core dispatched and
+                            // immediately cancelled. Record the cancellation so it is honoured
+                            // as soon as the host spawns.
+                            pendingNativeCancellations.add(msg.requestId);
+                            log.info('[agent-node] native mission cancellation recorded for pending worker', {
+                                requestId: msg.requestId,
+                                missionId: msg.missionId,
+                                featureId: msg.featureId,
+                            });
+                        }
+                    }
+                    else {
+                        log.warn('[agent-node] mission.run.cancel received for non-native runtime', {
+                            requestId: msg.requestId,
+                            missionId: msg.missionId,
+                            runtimeProvider: msg.runtimeProvider,
+                        });
+                    }
+                    break;
+                }
+                case 'mission.continuation.inspect.request':
+                    connection.send(inspectDroidMissionContinuation(msg));
+                    break;
+                case 'workspace.list.request':
+                    try {
+                        const readDirectory = () => listWorkspaceDirectory(msg.workspaceRoot, msg.relativePath, {
+                            scaffold: msg.scaffold,
+                            agentName: msg.agentName,
+                            cursor: msg.cursor,
+                            limit: msg.limit,
+                        });
+                        const result = executor.isRunActiveInWorkspace(msg.runId, msg.workspaceRoot)
+                            ? await readDirectory()
+                            : await workspaceLockManager.runAfterPendingWrites(msg.workspaceRoot, readDirectory);
+                        connection.send({
+                            type: 'workspace.list.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            entries: result.entries,
+                            directoryPage: result.directoryPage,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspacePathErrorResponse('workspace.list.response', msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'workspace.read.request':
+                    try {
+                        const readFile = () => readWorkspaceFile(msg.workspaceRoot, msg.relativePath, {
+                            scaffold: msg.scaffold,
+                            agentName: msg.agentName,
+                            offset: msg.offset,
+                            limit: msg.limit,
+                        });
+                        const result = executor.isRunActiveInWorkspace(msg.runId, msg.workspaceRoot)
+                            ? await readFile()
+                            : await workspaceLockManager.runAfterPendingWrites(msg.workspaceRoot, readFile);
+                        connection.send({
+                            type: 'workspace.read.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            content: result.content,
+                            mimeType: result.mimeType,
+                            size: result.size,
+                            modifiedAt: result.modifiedAt,
+                            offset: result.offset,
+                            limit: result.limit,
+                            nextOffset: result.nextOffset,
+                            hasMore: result.hasMore,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspacePathErrorResponse('workspace.read.response', msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'workspace.archive.request':
+                    try {
+                        const archiveDirectory = () => createWorkspaceDirectoryArchive(msg.workspaceRoot, msg.relativePath, {
+                            maxBytes: msg.maxBytes,
+                        });
+                        const result = await workspaceLockManager.runAfterPendingWrites(msg.workspaceRoot, archiveDirectory);
+                        connection.send({
+                            type: 'workspace.archive.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            archiveBase64: result.archiveBase64,
+                            byteSize: result.byteSize,
+                            fileCount: result.fileCount,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceArchiveErrorResponse(msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'library.mirror.apply.request':
+                    try {
+                        applyLibraryMirror(msg.workspaceRoot, {
+                            shared: msg.shared,
+                            personal: msg.personal,
+                        });
+                        connection.send({
+                            type: 'library.mirror.apply.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(libraryMirrorErrorResponse('library.mirror.apply.response', msg.requestId, error));
+                    }
+                    break;
+                case 'library.mirror.snapshot.request':
+                    try {
+                        const snapshot = snapshotLibraryMirror(msg.workspaceRoot);
+                        connection.send({
+                            type: 'library.mirror.snapshot.response',
+                            requestId: msg.requestId,
+                            shared: snapshot.shared,
+                            personal: snapshot.personal,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(libraryMirrorErrorResponse('library.mirror.snapshot.response', msg.requestId, error));
+                    }
+                    break;
+                case 'library.authority.delete.request':
+                    try {
+                        deleteLibraryAuthorityPath(msg.libraryRoot, msg.relativePath, {
+                            recursive: msg.recursive === true,
+                        });
+                        connection.send({
+                            type: 'library.authority.delete.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(libraryAuthorityDeleteErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'library.authority.rename.request':
+                    try {
+                        renameLibraryAuthorityPath(msg.libraryRoot, msg.relativePath, msg.nextRelativePath);
+                        connection.send({
+                            type: 'library.authority.rename.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(libraryAuthorityRenameErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'fs.read_path.request':
+                    try {
+                        const result = readExactPath(msg.absolutePath, {
+                            allowedRoot: msg.allowedRoot,
+                            trustedRoot: msg.trustedRoot,
+                            cursor: msg.cursor,
+                            offset: msg.offset,
+                            limit: msg.limit,
+                            maxPreviewBytes: msg.maxPreviewBytes,
+                            rawContentBase64: msg.rawContentBase64,
+                        });
+                        connection.send({
+                            type: 'fs.read_path.response',
+                            requestId: msg.requestId,
+                            absolutePath: result.absolutePath,
+                            kind: result.kind,
+                            ...(result.kind === 'file'
+                                ? {
+                                    content: result.content,
+                                    mimeType: result.mimeType,
+                                    size: result.size,
+                                    offset: result.offset,
+                                    limit: result.limit,
+                                    nextOffset: result.nextOffset,
+                                    hasMore: result.hasMore,
+                                    rawContentBase64: result.rawContentBase64,
+                                }
+                                : {
+                                    entries: result.entries,
+                                    directoryPage: result.directoryPage,
+                                }),
+                            modifiedAt: result.modifiedAt,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(fsPathErrorResponse('fs.read_path.response', msg.requestId, msg.absolutePath, error));
+                    }
+                    break;
+                case 'fs.path_suggest.request':
+                    try {
+                        const result = suggestDirectoryPaths(msg.query, { limit: msg.limit });
+                        connection.send({
+                            type: 'fs.path_suggest.response',
+                            requestId: msg.requestId,
+                            query: result.query,
+                            suggestions: result.suggestions,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(fsPathSuggestErrorResponse(msg.requestId, msg.query, error));
+                    }
+                    break;
+                case 'http.fetch_text.request':
+                    try {
+                        const authHeaders = resolvePanelApiJsonlAuthHeaders(config.panelApiJsonlAuthProfiles, msg.authProfile);
+                        const result = await fetchLoopbackHttpText(msg.url, {
+                            maxBytes: msg.maxBytes,
+                            allowedOrigins: config.panelApiJsonlAllowedOrigins,
+                            allowedUrlPrefixes: config.panelApiJsonlAllowedUrlPrefixes,
+                            ...(typeof msg.ifNoneMatch === 'string' && msg.ifNoneMatch.trim() ? { ifNoneMatch: msg.ifNoneMatch.trim() } : {}),
+                            ...(typeof msg.ifModifiedSince === 'string' && msg.ifModifiedSince.trim() ? { ifModifiedSince: msg.ifModifiedSince.trim() } : {}),
+                            ...(typeof msg.ifRange === 'string' && msg.ifRange.trim() ? { ifRange: msg.ifRange.trim() } : {}),
+                            ...(typeof msg.rangeStart === 'number' ? { rangeStart: msg.rangeStart } : {}),
+                            ...(typeof msg.rangeLength === 'number' ? { rangeLength: msg.rangeLength } : {}),
+                            ...(authHeaders ? { authHeaders } : {}),
+                        });
+                        connection.send({
+                            type: 'http.fetch_text.response',
+                            requestId: msg.requestId,
+                            url: result.url,
+                            content: result.content,
+                            status: result.status,
+                            contentType: result.contentType,
+                            size: result.size,
+                            partialContent: result.partialContent,
+                            rangeStart: result.rangeStart,
+                            rangeEnd: result.rangeEnd,
+                            totalSize: result.totalSize,
+                            hasMore: result.hasMore,
+                            notModified: result.notModified,
+                            etag: result.etag,
+                            lastModified: result.lastModified,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(httpFetchTextErrorResponse(msg.requestId, msg.url, error));
+                    }
+                    break;
+                case 'workspace.service_proxy.request':
+                    try {
+                        const result = await proxyWorkspaceServiceHttp(msg.url, {
+                            method: msg.method,
+                            headers: msg.headers,
+                            body: msg.body,
+                            maxBytes: msg.maxBytes,
+                        });
+                        connection.send({
+                            type: 'workspace.service_proxy.response',
+                            requestId: msg.requestId,
+                            url: result.url,
+                            method: result.method,
+                            status: result.status,
+                            body: result.body,
+                            contentType: result.contentType,
+                            size: result.size,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceServiceProxyErrorResponse(msg.requestId, msg.url, msg.method, error));
+                    }
+                    break;
+                case 'fs.read_path.stream.request':
+                    try {
+                        const info = statExactPathRawStream(msg.absolutePath, { allowedRoot: msg.allowedRoot });
+                        const stream = createExactPathReadStream(info.absolutePath);
+                        connection.send({
+                            type: 'fs.read_path.stream.start',
+                            requestId: msg.requestId,
+                            absolutePath: info.absolutePath,
+                            mimeType: info.mimeType,
+                            size: info.size,
+                            modifiedAt: info.modifiedAt,
+                        });
+                        stream.on('data', (chunk) => {
+                            connection.send({
+                                type: 'fs.read_path.stream.chunk',
+                                requestId: msg.requestId,
+                                encoding: 'base64',
+                                chunk: Buffer.isBuffer(chunk) ? chunk.toString('base64') : Buffer.from(chunk).toString('base64'),
+                            });
+                        });
+                        stream.on('end', () => {
+                            connection.send({
+                                type: 'fs.read_path.stream.end',
+                                requestId: msg.requestId,
+                            });
+                        });
+                        stream.on('error', (error) => {
+                            connection.send(fsPathStreamEndErrorResponse(msg.requestId, error));
+                        });
+                    }
+                    catch (error) {
+                        connection.send(fsPathStreamEndErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'workspace.inspect.request':
+                    try {
+                        connection.send({
+                            type: 'workspace.inspect.response',
+                            requestId: msg.requestId,
+                            inspect: inspectWorkspace(msg.workspaceRoot),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceInspectErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'workspace.git_status.request':
+                    try {
+                        connection.send({
+                            type: 'workspace.git_status.response',
+                            requestId: msg.requestId,
+                            status: getWorkspaceGitStatus(msg.workspaceRoot),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceGitStatusErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'workspace.git_diff.request':
+                    try {
+                        connection.send({
+                            type: 'workspace.git_diff.response',
+                            requestId: msg.requestId,
+                            diff: getWorkspaceGitDiff(msg.workspaceRoot, msg.mode),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceGitDiffErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'workspace.git_action.request':
+                    try {
+                        connection.send({
+                            type: 'workspace.git_action.response',
+                            requestId: msg.requestId,
+                            result: runWorkspaceGitAction(msg.workspaceRoot, msg.action, msg.commitMessage),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceGitActionErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'claude.controls.request':
+                    try {
+                        connection.send({
+                            type: 'claude.controls.response',
+                            requestId: msg.requestId,
+                            controls: await executor.getClaudeControls(msg.target),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeControlErrorResponse('claude.controls.response', msg.requestId, error));
+                    }
+                    break;
+                case 'claude.set_mode.request':
+                    try {
+                        connection.send({
+                            type: 'claude.set_mode.response',
+                            requestId: msg.requestId,
+                            controls: await executor.setClaudeMode(msg.target, msg.modeId),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeControlErrorResponse('claude.set_mode.response', msg.requestId, error));
+                    }
+                    break;
+                case 'claude.set_model.request':
+                    try {
+                        connection.send({
+                            type: 'claude.set_model.response',
+                            requestId: msg.requestId,
+                            controls: await executor.setClaudeModel(msg.target, msg.modelId ?? null),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeControlErrorResponse('claude.set_model.response', msg.requestId, error));
+                    }
+                    break;
+                case 'claude.command.request':
+                    try {
+                        const { controls, result } = await executor.executeClaudeCommand(msg.target, msg.commandName, msg.args ?? null);
+                        connection.send({
+                            type: 'claude.command.response',
+                            requestId: msg.requestId,
+                            controls,
+                            result,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeControlErrorResponse('claude.command.response', msg.requestId, error));
+                    }
+                    break;
+                case 'codex.model.list.request':
+                    try {
+                        const result = await codexAppServerRpc.listModels({
+                            workspaceRoot: msg.workspaceRoot ?? null,
+                            cursor: msg.cursor ?? null,
+                            limit: msg.limit ?? null,
+                            includeHidden: msg.includeHidden ?? null,
+                        });
+                        connection.send({
+                            type: 'codex.model.list.response',
+                            requestId: msg.requestId,
+                            models: result.models,
+                            nextCursor: result.nextCursor,
+                            defaultModel: result.defaultModel,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexAppServerErrorResponse('codex.model.list.response', msg.requestId, error));
+                    }
+                    break;
+                case 'codex.skills.list.request':
+                    try {
+                        const result = await codexAppServerRpc.listSkills({
+                            workspaceRoot: msg.workspaceRoot,
+                            skillRoots: msg.skillRoots,
+                            forceReload: msg.forceReload,
+                        });
+                        connection.send({
+                            type: 'codex.skills.list.response',
+                            requestId: msg.requestId,
+                            data: result.data,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexAppServerErrorResponse('codex.skills.list.response', msg.requestId, error));
+                    }
+                    break;
+                case 'codex.thread.list.request':
+                    try {
+                        const result = await codexAppServerRpc.listThreads({
+                            workspaceRoot: msg.workspaceRoot,
+                            cursor: msg.cursor ?? null,
+                            limit: msg.limit ?? null,
+                            archived: msg.archived ?? null,
+                            searchTerm: msg.searchTerm ?? null,
+                            useStateDbOnly: msg.useStateDbOnly,
+                        });
+                        connection.send({
+                            type: 'codex.thread.list.response',
+                            requestId: msg.requestId,
+                            threads: result.threads,
+                            nextCursor: result.nextCursor,
+                            backwardsCursor: result.backwardsCursor,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexAppServerErrorResponse('codex.thread.list.response', msg.requestId, error));
+                    }
+                    break;
+                case 'codex.thread.read.request':
+                    try {
+                        const result = await codexAppServerRpc.readThread({
+                            workspaceRoot: msg.workspaceRoot,
+                            threadId: msg.threadId,
+                            includeTurns: msg.includeTurns,
+                        });
+                        connection.send({
+                            type: 'codex.thread.read.response',
+                            requestId: msg.requestId,
+                            thread: result.thread,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexAppServerErrorResponse('codex.thread.read.response', msg.requestId, error));
+                    }
+                    break;
+                case 'terminal.list.request':
+                    try {
+                        connection.send({
+                            type: 'terminal.list.response',
+                            requestId: msg.requestId,
+                            workspaceRoot: msg.workspaceRoot,
+                            terminals: terminalManager.list(msg.workspaceRoot),
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.list.response', msg.requestId, error, {
+                            workspaceRoot: msg.workspaceRoot,
+                        }));
+                    }
+                    break;
+                case 'terminal.create.request':
+                    try {
+                        const terminal = terminalManager.create({
+                            terminalId: randomUUID(),
+                            workspaceRoot: msg.workspaceRoot,
+                            cwd: msg.cwd,
+                            name: msg.name,
+                            startupCommand: msg.startupCommand,
+                            closeOnStartupCommand: msg.closeOnStartupCommand,
+                            cols: msg.cols,
+                            rows: msg.rows,
+                        });
+                        connection.send({
+                            type: 'terminal.create.response',
+                            requestId: msg.requestId,
+                            terminal,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.create.response', msg.requestId, error));
+                    }
+                    break;
+                case 'terminal.snapshot.request':
+                    try {
+                        const snapshot = terminalManager.snapshot(msg.terminalId);
+                        connection.send({
+                            type: 'terminal.snapshot.response',
+                            requestId: msg.requestId,
+                            terminal: snapshot.terminal,
+                            buffer: snapshot.buffer,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.snapshot.response', msg.requestId, error));
+                    }
+                    break;
+                case 'terminal.input.request':
+                    try {
+                        terminalManager.input(msg.terminalId, msg.data);
+                        connection.send({
+                            type: 'terminal.input.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.input.response', msg.requestId, error));
+                    }
+                    break;
+                case 'terminal.resize.request':
+                    try {
+                        terminalManager.resize(msg.terminalId, msg.cols, msg.rows);
+                        connection.send({
+                            type: 'terminal.resize.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.resize.response', msg.requestId, error));
+                    }
+                    break;
+                case 'terminal.close.request':
+                    try {
+                        terminalManager.close(msg.terminalId);
+                        connection.send({
+                            type: 'terminal.close.response',
+                            requestId: msg.requestId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(terminalErrorResponse('terminal.close.response', msg.requestId, error));
+                    }
+                    break;
+                case 'skills.list.request':
+                    try {
+                        syncNativeSkillsFromRequest(msg);
+                        const result = listSkills(msg.skillRoots, msg.path);
+                        connection.send({
+                            type: 'skills.list.response',
+                            requestId: msg.requestId,
+                            roots: result.roots,
+                            path: result.path,
+                            skills: result.skills,
+                            entries: result.entries,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(skillListErrorResponse(msg.requestId, msg.skillRoots, msg.path ?? null, error));
+                    }
+                    break;
+                case 'skills.read.request':
+                    try {
+                        syncNativeSkillsFromRequest(msg);
+                        const result = readSkillFile(msg.skillRoots, msg.path);
+                        connection.send({
+                            type: 'skills.read.response',
+                            requestId: msg.requestId,
+                            path: result.path,
+                            content: result.content,
+                            mimeType: result.mimeType,
+                            size: result.size,
+                            modifiedAt: result.modifiedAt,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(skillReadErrorResponse(msg.requestId, msg.path, error));
+                    }
+                    break;
+                case 'codex.transcript.list.request':
+                    try {
+                        const result = listCodexTranscriptFiles(msg.maxFiles);
+                        connection.send({
+                            type: 'codex.transcript.list.response',
+                            requestId: msg.requestId,
+                            rootPath: result.rootPath,
+                            files: result.files,
+                            truncated: result.truncated,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexTranscriptListErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'codex.transcript.read.request':
+                    try {
+                        const result = readCodexTranscriptFile(msg.path);
+                        connection.send({
+                            type: 'codex.transcript.read.response',
+                            requestId: msg.requestId,
+                            rootPath: result.rootPath,
+                            path: result.path,
+                            content: result.content,
+                            size: result.size,
+                            modifiedAt: result.modifiedAt,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(codexTranscriptReadErrorResponse(msg.requestId, msg.path, error));
+                    }
+                    break;
+                case 'claude.transcript.list.request':
+                    try {
+                        const result = listClaudeTranscriptFiles(msg.workspaceRoot, msg.maxFiles);
+                        connection.send({
+                            type: 'claude.transcript.list.response',
+                            requestId: msg.requestId,
+                            rootPath: result.rootPath,
+                            files: result.files,
+                            truncated: result.truncated,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeTranscriptListErrorResponse(msg.requestId, error));
+                    }
+                    break;
+                case 'claude.transcript.read.request':
+                    try {
+                        const result = readClaudeTranscriptFile(msg.workspaceRoot, msg.path);
+                        connection.send({
+                            type: 'claude.transcript.read.response',
+                            requestId: msg.requestId,
+                            rootPath: result.rootPath,
+                            path: result.path,
+                            content: result.content,
+                            size: result.size,
+                            modifiedAt: result.modifiedAt,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(claudeTranscriptReadErrorResponse(msg.requestId, msg.path, error));
+                    }
+                    break;
+                case 'workspace.write.request':
+                    try {
+                        const result = await workspaceLockManager.runExclusive(msg.workspaceRoot, async () => writeWorkspaceFile(msg.workspaceRoot, msg.relativePath, msg.content, msg.mode, {
+                            scaffold: msg.scaffold,
+                            agentName: msg.agentName,
+                            contentEncoding: msg.contentEncoding,
+                        }));
+                        connection.send({
+                            type: 'workspace.write.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            ok: true,
+                            modifiedAt: result.modifiedAt,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceWriteErrorResponse(msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'workspace.extract.request':
+                    try {
+                        const result = await workspaceLockManager.runExclusive(msg.workspaceRoot, async () => extractWorkspaceDirectoryArchive(msg.workspaceRoot, msg.relativePath, msg.archiveBase64, {
+                            maxBytes: msg.maxBytes,
+                            overwrite: msg.overwrite === true,
+                        }));
+                        connection.send({
+                            type: 'workspace.extract.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            ok: true,
+                            byteSize: result.byteSize,
+                            fileCount: result.fileCount,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceExtractErrorResponse(msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'workspace.delete_file.request':
+                    try {
+                        const result = await workspaceLockManager.runExclusive(msg.workspaceRoot, async () => deleteWorkspaceFile(msg.workspaceRoot, msg.relativePath));
+                        connection.send({
+                            type: 'workspace.delete_file.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceDeleteFileErrorResponse(msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'workspace.delete_path.request':
+                    try {
+                        const result = await workspaceLockManager.runExclusive(msg.workspaceRoot, async () => deleteWorkspacePath(msg.workspaceRoot, msg.relativePath, { recursive: msg.recursive === true }));
+                        connection.send({
+                            type: 'workspace.delete_path.response',
+                            requestId: msg.requestId,
+                            relativePath: result.relativePath,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceDeletePathErrorResponse(msg.requestId, msg.relativePath, error));
+                    }
+                    break;
+                case 'host.close':
+                    executor.closeHost(msg.hostKey);
+                    log.info('[agent-node] host closed', { hostKey: msg.hostKey });
+                    break;
+                case 'codex.conversation.summary.request':
+                    try {
+                        const content = await runCodexConversationSummary({
+                            db,
+                            config,
+                            prompt: msg.prompt,
+                            envVars: msg.envVars,
+                        });
+                        connection.send({
+                            type: 'codex.conversation.summary.response',
+                            requestId: msg.requestId,
+                            content,
+                        });
+                    }
+                    catch (error) {
+                        connection.send({
+                            type: 'codex.conversation.summary.response',
+                            requestId: msg.requestId,
+                            error: String(error?.message ?? error),
+                        });
+                    }
+                    break;
+                case 'agent.cleanup.request':
+                    try {
+                        const result = await executor.cleanupAgentRuntime(msg.hostKeys, msg.sessionKeys);
+                        log.info('[agent-node] agent runtime cleaned up', {
+                            agentId: msg.agentId,
+                            hostKeys: msg.hostKeys,
+                            sessionKeys: msg.sessionKeys,
+                            ...result,
+                        });
+                        connection.send({
+                            type: 'agent.cleanup.response',
+                            requestId: msg.requestId,
+                            agentId: msg.agentId,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send({
+                            type: 'agent.cleanup.response',
+                            requestId: msg.requestId,
+                            agentId: msg.agentId,
+                            error: String(error?.message ?? error),
+                        });
+                    }
+                    break;
+                case 'workspace.reset.request':
+                    try {
+                        executor.resetWorkspace(msg.workspaceRoot);
+                        await workspaceLockManager.runExclusive(msg.workspaceRoot, async () => {
+                            resetWorkspaceDirectory(msg.workspaceRoot, msg.agentName);
+                        });
+                        connection.send({
+                            type: 'workspace.reset.response',
+                            requestId: msg.requestId,
+                            workspaceRoot: msg.workspaceRoot,
+                            ok: true,
+                        });
+                    }
+                    catch (error) {
+                        connection.send(workspaceResetErrorResponse(msg.requestId, msg.workspaceRoot, error));
+                    }
+                    break;
+                default: {
+                    const _exhaustive = msg;
+                    log.warn('[agent-node] unknown message', _exhaustive);
+                }
+            }
+        })().catch((error) => {
+            log.warn('[agent-node] message handler error', {
+                type: msg.type,
+                error: String(error?.message ?? error),
+            });
+        });
+    };
+    connection = new CoreConnection(config, handleMessage, {
+        getTerminalBackendAvailable: () => terminalManager.isBackendAvailable(),
+        onConnected: () => {
+            log.info(`[agent-node] connected to ${config.coreUrl} as ${config.nodeId}`);
+        },
+        onDisconnected: () => {
+            log.warn('[agent-node] disconnected from core, waiting to reconnect');
+            executor?.closeSoloHosts();
+        },
+    });
+    executor = new Executor({
+        db,
+        config,
+        send: (msg) => connection.send(msg),
+        workspaceLockManager,
+    });
+    nativeAgentExecutor = new NativeMissionAgentExecutor({
+        db,
+        config,
+        send: (msg) => connection.send(msg),
+    });
+    process.on('uncaughtException', (error) => {
+        if (!isRecoverableRuntimeStreamError(error)) {
+            throw error;
+        }
+        const failed = executor.failCurrentRestoredDispatch(error);
+        log.warn('[agent-node] swallowed recoverable runtime stream error', {
+            error: String(error?.message ?? error),
+            failedRestoredDispatch: failed,
+        });
+    });
+    const hostSnapshotTimer = setInterval(() => {
+        publishHostSnapshot();
+        publishRuntimeSnapshot();
+    }, config.heartbeatIntervalMs);
+    hostSnapshotTimer.unref?.();
+    await connection.connect();
+    const shutdown = () => {
+        log.warn('[agent-node] shutting down');
+        clearInterval(hostSnapshotTimer);
+        executor.close();
+        connection.close();
+        db.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+await main();
+function syncNativeSkillsFromRequest(msg) {
+    if (!msg.agentType || !msg.workspaceRoot)
+        return;
+    ensureNativeSkillMounts({
+        agentType: msg.agentType,
+        workspaceRoot: msg.workspaceRoot,
+        skillRoots: msg.skillRoots,
+    });
+}
+function workspacePathErrorResponse(type, requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type,
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type,
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function fsPathErrorResponse(type, requestId, absolutePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type,
+            requestId,
+            absolutePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type,
+        requestId,
+        absolutePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function httpFetchTextErrorResponse(requestId, url, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'http.fetch_text.response',
+            requestId,
+            url,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'http.fetch_text.response',
+        requestId,
+        url,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceServiceProxyErrorResponse(requestId, url, method, error) {
+    const normalizedMethod = method ?? 'GET';
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.service_proxy.response',
+            requestId,
+            url,
+            method: normalizedMethod,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.service_proxy.response',
+        requestId,
+        url,
+        method: normalizedMethod,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function fsPathSuggestErrorResponse(requestId, query, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'fs.path_suggest.response',
+            requestId,
+            query,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'fs.path_suggest.response',
+        requestId,
+        query,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function fsPathStreamEndErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'fs.read_path.stream.end',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'fs.read_path.stream.end',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceInspectErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceInspectError) {
+        return {
+            type: 'workspace.inspect.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.inspect.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function terminalErrorResponse(type, requestId, error, extra) {
+    if (error instanceof TerminalManagerError) {
+        return {
+            type,
+            requestId,
+            ...extra,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type,
+        requestId,
+        ...extra,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceGitStatusErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceGitError) {
+        return {
+            type: 'workspace.git_status.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.git_status.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceGitDiffErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceGitError) {
+        return {
+            type: 'workspace.git_diff.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.git_diff.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceGitActionErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceGitError) {
+        return {
+            type: 'workspace.git_action.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.git_action.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function claudeControlErrorResponse(type, requestId, error) {
+    return {
+        type,
+        requestId,
+        error: String(error?.message ?? error),
+    };
+}
+function codexAppServerErrorResponse(type, requestId, error) {
+    return {
+        type,
+        requestId,
+        error: String(error?.message ?? error),
+    };
+}
+function workspaceResetErrorResponse(requestId, workspaceRoot, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.reset.response',
+            requestId,
+            workspaceRoot,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.reset.response',
+        requestId,
+        workspaceRoot,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceWriteErrorResponse(requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.write.response',
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.write.response',
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceArchiveErrorResponse(requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.archive.response',
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.archive.response',
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceExtractErrorResponse(requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.extract.response',
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.extract.response',
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceDeleteFileErrorResponse(requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.delete_file.response',
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.delete_file.response',
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function workspaceDeletePathErrorResponse(requestId, relativePath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'workspace.delete_path.response',
+            requestId,
+            relativePath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'workspace.delete_path.response',
+        requestId,
+        relativePath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function libraryMirrorErrorResponse(type, requestId, error) {
+    return {
+        type,
+        requestId,
+        error: String(error?.message ?? error),
+    };
+}
+function libraryAuthorityDeleteErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'library.authority.delete.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'library.authority.delete.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function libraryAuthorityRenameErrorResponse(requestId, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'library.authority.rename.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'library.authority.rename.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function skillListErrorResponse(requestId, skillRoots, skillPath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'skills.list.response',
+            requestId,
+            roots: skillRoots,
+            path: skillPath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'skills.list.response',
+        requestId,
+        roots: skillRoots,
+        path: skillPath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function skillReadErrorResponse(requestId, skillPath, error) {
+    if (error instanceof WorkspaceFsError) {
+        return {
+            type: 'skills.read.response',
+            requestId,
+            path: skillPath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'skills.read.response',
+        requestId,
+        path: skillPath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function codexTranscriptListErrorResponse(requestId, error) {
+    if (error instanceof CodexTranscriptFsError) {
+        return {
+            type: 'codex.transcript.list.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'codex.transcript.list.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function codexTranscriptReadErrorResponse(requestId, transcriptPath, error) {
+    if (error instanceof CodexTranscriptFsError) {
+        return {
+            type: 'codex.transcript.read.response',
+            requestId,
+            path: transcriptPath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'codex.transcript.read.response',
+        requestId,
+        path: transcriptPath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function claudeTranscriptListErrorResponse(requestId, error) {
+    if (error instanceof ClaudeTranscriptFsError) {
+        return {
+            type: 'claude.transcript.list.response',
+            requestId,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'claude.transcript.list.response',
+        requestId,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}
+function claudeTranscriptReadErrorResponse(requestId, transcriptPath, error) {
+    if (error instanceof ClaudeTranscriptFsError) {
+        return {
+            type: 'claude.transcript.read.response',
+            requestId,
+            path: transcriptPath,
+            error: error.message,
+            errorCode: error.code,
+        };
+    }
+    return {
+        type: 'claude.transcript.read.response',
+        requestId,
+        path: transcriptPath,
+        error: String(error?.message ?? error),
+        errorCode: 'io_error',
+    };
+}