@cydm/magic-shell-agent-node 0.1.0

package/dist/node.js

@@ -0,0 +1,1954 @@
+import { WebSocketClient } from "./ws-client.js";
+import { SessionManager } from "./session-manager.js";
+import { LocalDirectServer } from "./local-direct-server.js";
+import { loadPlugins, getDefaultPluginDir } from "./plugin-loader.js";
+import { adapterRegistry } from "./adapters/registry.js";
+import { WorkerRegistry } from "./worker-registry.js";
+import { buildPrimarySessionPrompt, readPieSessionSnapshot, withPrimaryPieExtensionPath, } from "./primary-agent-bridge.js";
+import { readPieSessionControlState, writePieSessionControlCommand, } from "./pie-session-control.js";
+import { buildDirectoryList } from "./directory-browser.js";
+import { attachWorkerSession, inspectWorkerSession, restartWorkerSession, stopWorkerSession, } from "./worker-control.js";
+import { spawnManagedWorker } from "./worker-runtime.js";
+import { createNodeConversationState, recordConversationTurn, rememberNodeSpawn, } from "./node-conversation.js";
+import { getLastMeaningfulWorkerMessage, stripAnsi, summarizeRecentWorkerOutput, } from "./worker-output.js";
+import { claudeNeedsTrustConfirmation, getLastClaudeWorkerMessage, isClaudeReadyForTask, isClaudeCodeWorker, summarizeClaudeWorkerOutput, } from "./claude-worker.js";
+import { runClaudeExec } from "./claude-exec.js";
+import { codexNeedsTrustConfirmation, getLastCodexWorkerMessage, isCodexReadyForTask, isCodexWorker, summarizeCodexWorkerOutput, } from "./codex-worker.js";
+import { runCodexExec } from "./codex-exec.js";
+import { extractTerminalMetadata, normalizeWorkerTitleCandidate, } from "./terminal-metadata.js";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export class AgentNode {
+    options;
+    wsClient;
+    localDirectServer;
+    localDirectInfo;
+    sessionManager;
+    workerRegistry;
+    plugins;
+    running = false;
+    sessionTitleBuffers = new Map();
+    primaryAgent;
+    nodeConversation = createNodeConversationState();
+    lastFailedNamedWorker;
+    preferredWorkerPluginName = "pie";
+    syntheticSessionResults = new Map();
+    liveAttachedSessions = new Set();
+    remoteAttachedSessions = new Set();
+    localAttachedSessions = new Set();
+    relayConnectedOnce = false;
+    constructor(options) {
+        this.options = options;
+        this.plugins = new Map();
+        this.sessionManager = new SessionManager(adapterRegistry);
+        this.workerRegistry = new WorkerRegistry();
+        const primaryPluginName = options.primaryPluginName || "pie";
+        const primaryLaunchMode = options.primaryLaunchMode || (primaryPluginName === "pie" ? "session" : "headless");
+        this.primaryAgent = {
+            pluginName: primaryPluginName,
+            sessionId: `primary-${options.nodeId}`,
+            launchMode: primaryLaunchMode,
+            status: "starting",
+        };
+        this.nodeConversation = createNodeConversationState();
+        this.wsClient = new WebSocketClient({
+            url: options.relayUrl,
+            nodeId: options.nodeId,
+            password: options.password,
+            autoReconnect: options.autoReconnect ?? true,
+        });
+        this.wsClient.onStatus((status, error) => {
+            if (status === "connected") {
+                void this.onRelayConnected();
+                return;
+            }
+            if (status === "error" && error) {
+                console.warn(`[AgentNode] Relay transport error: ${error.message}`);
+            }
+        });
+    }
+    getOptions() {
+        return this.options;
+    }
+    getLocalDirectInfo() {
+        return this.localDirectInfo;
+    }
+    /**
+     * 启动 AgentNode
+     */
+    async start() {
+        console.log(`[AgentNode] Starting...`);
+        console.log(`[AgentNode] Node ID: ${this.options.nodeId}`);
+        console.log(`[AgentNode] Relay: ${this.options.relayUrl}`);
+        // 1. 加载插件
+        this.plugins = loadPlugins({ dir: this.options.pluginDir });
+        if (this.plugins.size === 0) {
+            console.warn("[AgentNode] No plugins loaded!");
+        }
+        // 2. 设置消息处理器
+        this.setupMessageHandlers();
+        // 3. 启动本地直连入口
+        if (this.options.enableLocalDirect !== false) {
+            await this.startLocalDirectServer();
+        }
+        // 4. 连接 Relay
+        try {
+            await this.wsClient.connect();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[AgentNode] Relay connection unavailable at startup: ${message}`);
+            if (this.options.autoReconnect === false && !this.localDirectServer) {
+                throw error;
+            }
+        }
+        // 5. 设置会话输出转发
+        this.sessionManager.onOutput((sessionId, output) => {
+            this.handleSessionOutput(sessionId, output);
+        });
+        this.sessionManager.onExit((sessionId, agentId, code) => {
+            if (sessionId === this.primaryAgent.sessionId) {
+                this.primaryAgent = {
+                    ...this.primaryAgent,
+                    status: code === 0 ? "stopped" : "failed",
+                    lastError: code === 0 ? undefined : `Exited with code ${code}`,
+                };
+                this.broadcastWorkerList();
+            }
+            const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+            if (!worker)
+                return;
+            if (worker.agentId !== agentId) {
+                return;
+            }
+            if (code !== 0) {
+                this.workerRegistry.recordEvent(worker.agentId, {
+                    type: "error",
+                    timestamp: Date.now(),
+                    message: `process exited with code ${code}`,
+                });
+            }
+            const previousWorker = { ...worker };
+            const updatedWorker = this.workerRegistry.updateWorkerStatus(worker.agentId, code === 0 ? "stopped" : "failed", { exitCode: code, lastError: code === 0 ? undefined : `Exited with code ${code}` });
+            if (updatedWorker) {
+                this.maybeNarrateWorkerStateChange(previousWorker, updatedWorker);
+            }
+            this.broadcastWorkerList();
+        });
+        this.running = true;
+        await this.ensurePrimaryAgent();
+        console.log("[AgentNode] Started successfully");
+    }
+    /**
+     * 停止 AgentNode
+     */
+    async stop() {
+        this.running = false;
+        console.log("[AgentNode] Stopping...");
+        // 停止所有会话
+        await this.sessionManager.stopAll();
+        if (this.localDirectServer) {
+            await this.localDirectServer.stop();
+            this.localDirectServer = undefined;
+        }
+        // 断开 WebSocket
+        this.wsClient.disconnect();
+        console.log("[AgentNode] Stopped");
+    }
+    /**
+     * 设置消息处理器
+     */
+    setupMessageHandlers() {
+        this.wsClient.onMessage(async (message) => {
+            await this.handleIncomingMessage(message, "relay");
+        });
+    }
+    async handleIncomingMessage(message, source = "relay") {
+        switch (message.type) {
+            case "auth":
+                return;
+            case "input":
+                if (message.sessionId && message.data) {
+                    await this.ensureSessionForInteractiveMessage(message.sessionId, "input");
+                    this.captureWorkerTitleFromInput(message.sessionId, message.data);
+                    this.sessionManager.sendInput(message.sessionId, message.data);
+                }
+                return;
+            case "resize":
+                if (message.sessionId && message.cols && message.rows) {
+                    await this.ensureSessionForInteractiveMessage(message.sessionId, "resize");
+                    this.sessionManager.resize(message.sessionId, message.cols, message.rows);
+                }
+                return;
+            case "list_workers":
+                this.broadcastWorkerList();
+                return;
+            case "spawn_worker": {
+                const pluginName = message.pluginName || this.preferredWorkerPluginName || "pie";
+                const sessionId = message.sessionId || generateSessionId();
+                try {
+                    await this.spawnWorker({
+                        sessionId,
+                        pluginName,
+                        cwd: message.cwd,
+                        taskSummary: message.taskSummary,
+                    });
+                    this.rememberNodeSpawn(message.taskSummary, sessionId);
+                }
+                catch (err) {
+                    this.sendToSource(source, {
+                        type: "error",
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
+            case "attach_worker":
+                if (message.sessionId) {
+                    const responses = attachWorkerSession(message.sessionId, {
+                        workerRegistry: this.workerRegistry,
+                        sessionManager: this.sessionManager,
+                    });
+                    for (const response of responses) {
+                        this.sendToSource(source, response);
+                    }
+                }
+                return;
+            case "stop_worker":
+                if (message.sessionId) {
+                    await stopWorkerSession(message.sessionId, {
+                        workerRegistry: this.workerRegistry,
+                        sessionManager: this.sessionManager,
+                        clearSessionTitle: (sessionId) => {
+                            this.sessionTitleBuffers.delete(sessionId);
+                        },
+                        broadcastWorkerList: () => {
+                            this.broadcastWorkerList();
+                        },
+                        spawnWorker: (options) => this.spawnWorker(options),
+                    });
+                }
+                return;
+            case "restart_worker":
+                if (message.sessionId) {
+                    const error = await restartWorkerSession(message.sessionId, {
+                        workerRegistry: this.workerRegistry,
+                        sessionManager: this.sessionManager,
+                        clearSessionTitle: (sessionId) => {
+                            this.sessionTitleBuffers.delete(sessionId);
+                        },
+                        broadcastWorkerList: () => {
+                            this.broadcastWorkerList();
+                        },
+                        spawnWorker: (options) => this.spawnWorker(options),
+                    });
+                    if (error) {
+                        this.sendToSource(source, {
+                            type: "error",
+                            error,
+                        });
+                    }
+                }
+                return;
+            case "inspect_worker":
+                if (message.sessionId) {
+                    const response = inspectWorkerSession(message.sessionId, {
+                        workerRegistry: this.workerRegistry,
+                        sessionManager: this.sessionManager,
+                    });
+                    if (response) {
+                        this.sendToSource(source, response);
+                    }
+                }
+                return;
+            case "browse_dirs":
+                this.sendServerMessage(await buildDirectoryList(message.path));
+                return;
+            case "node_message":
+                if (message.text?.trim()) {
+                    const resolvedReply = await this.handlePrimaryMessage(message.text);
+                    this.sendServerMessage({
+                        type: "node_reply",
+                        text: resolvedReply.text,
+                        actionType: resolvedReply.actionType,
+                        actionLabel: resolvedReply.actionLabel,
+                        actionTaskSummary: resolvedReply.actionTaskSummary,
+                        actionSessionId: resolvedReply.actionSessionId,
+                    });
+                }
+                return;
+            case "control":
+                await this.handleControlEnvelope(message, source);
+                return;
+            case "auth_success":
+                console.log(`[AgentNode] Browser connected: ${message.sessionId}`);
+                return;
+            case "ping":
+                this.sendToSource(source, { type: "pong" });
+                return;
+            default:
+                console.warn(`[AgentNode] Unknown message type: ${message.type}`);
+        }
+    }
+    /**
+     * 创建新会话
+     */
+    async spawnWorker(options) {
+        const sessionMessage = await spawnManagedWorker(options, {
+            nodeId: this.options.nodeId,
+            plugins: this.plugins,
+            sessionManager: this.sessionManager,
+            workerRegistry: this.workerRegistry,
+        });
+        if (!options.taskSummary) {
+            void this.primeInteractiveWorkerSession(options.sessionId).catch(() => { });
+        }
+        if (options.taskSummary) {
+            await this.dispatchInitialWorkerTask(options.sessionId, options.taskSummary);
+        }
+        this.broadcastWorkerList();
+        this.sendServerMessage(sessionMessage);
+    }
+    /**
+     * Backward-compatible wrapper while the transport still speaks in session terms.
+     */
+    async createSession(sessionId, pluginName) {
+        await this.spawnWorker({
+            sessionId,
+            pluginName,
+        });
+    }
+    async waitForPrimaryAgentSessionId(timeoutMs = 6000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() <= deadline) {
+            if (this.primaryAgent.agentSessionId) {
+                return this.primaryAgent.agentSessionId;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        return this.primaryAgent.agentSessionId || null;
+    }
+    async sendPromptToPrimarySession(prompt) {
+        const sessionId = this.primaryAgent.sessionId;
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) {
+                throw new Error("Primary session is not available");
+            }
+            const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+            if (bufferedOutput.length > 0 || attempt >= 3) {
+                this.sessionManager.sendInput(sessionId, `${prompt}\r`);
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        this.sessionManager.sendInput(sessionId, `${prompt}\r`);
+    }
+    formatSessionControlInput(message) {
+        if (!message) {
+            return "\r";
+        }
+        if (message.endsWith("\r") || message.endsWith("\n")) {
+            return message;
+        }
+        return `${message}\r`;
+    }
+    async queryPrimarySessionText(text) {
+        await this.ensurePrimaryAgent();
+        const session = this.sessionManager.getSession(this.primaryAgent.sessionId);
+        if (!session || this.primaryAgent.pluginName !== "pie" || this.primaryAgent.launchMode !== "session") {
+            return null;
+        }
+        const agentSessionId = await this.waitForPrimaryAgentSessionId();
+        if (!agentSessionId) {
+            throw new Error("Primary session is running but its Pie session ID is still unavailable");
+        }
+        const before = readPieSessionSnapshot(agentSessionId);
+        const prompt = buildPrimarySessionPrompt(text, {
+            pluginName: this.primaryAgent.pluginName,
+            preferredWorkerPluginName: this.preferredWorkerPluginName,
+            lastTaskSummary: this.nodeConversation.lastTaskSummary,
+            lastWorkerSessionId: this.nodeConversation.lastWorkerSessionId,
+            history: this.nodeConversation.history,
+            liveWorkers: this.workerRegistry
+                .listWorkers()
+                .filter((worker) => worker.status !== "stopped" && worker.status !== "failed"),
+        });
+        this.primaryAgent = {
+            ...this.primaryAgent,
+            activityState: "busy",
+            lastError: undefined,
+        };
+        this.broadcastWorkerList();
+        try {
+            await this.sendPromptToPrimarySession(prompt);
+            const deadline = Date.now() + 90_000;
+            while (Date.now() <= deadline) {
+                const after = readPieSessionSnapshot(agentSessionId);
+                if (after
+                    && after.messageCount > (before?.messageCount || 0)
+                    && after.lastAssistantText
+                    && after.lastAssistantText !== before?.lastAssistantText
+                    && after.lastMessageRole === "assistant"
+                    && !after.lastAssistantHasToolCall
+                    && Date.now() - after.updatedAt >= 750) {
+                    return after.lastAssistantText;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+            throw new Error("Primary session did not produce a new assistant message in time");
+        }
+        finally {
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                activityState: "ready",
+            };
+            this.broadcastWorkerList();
+        }
+    }
+    async dispatchInitialWorkerTask(sessionId, taskSummary) {
+        const session = this.sessionManager.getSession(sessionId);
+        const pluginName = session?.plugin.name;
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        if (worker) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: "delegating",
+                coordinationTaskSummary: taskSummary,
+                activityState: "busy",
+                activityUpdatedAt: Date.now(),
+            });
+        }
+        try {
+            if (pluginName && isClaudeCodeWorker(pluginName)) {
+                await this.seedClaudeWorkerTask(sessionId, taskSummary);
+                return;
+            }
+            if (pluginName && isCodexWorker(pluginName)) {
+                await this.seedCodexWorkerTask(sessionId, taskSummary);
+                return;
+            }
+            await this.seedWorkerTask(sessionId, taskSummary);
+        }
+        catch (error) {
+            if (worker) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.workerRegistry.updateWorker(worker.agentId, {
+                    status: "blocked",
+                    lastError: message,
+                    coordinationState: "idle",
+                });
+                this.workerRegistry.recordEvent(worker.agentId, {
+                    type: "error",
+                    timestamp: Date.now(),
+                    message,
+                });
+            }
+            this.broadcastWorkerList();
+        }
+    }
+    async seedWorkerTask(sessionId, taskSummary) {
+        const prompt = `${taskSummary}\r`;
+        for (let attempt = 0; attempt < 10; attempt += 1) {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) {
+                throw new Error(`Worker session disappeared before task dispatch: ${sessionId}`);
+            }
+            const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+            if (bufferedOutput.length > 0 || attempt >= 3) {
+                this.sessionManager.sendInput(sessionId, prompt);
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        this.sessionManager.sendInput(sessionId, prompt);
+    }
+    async primeInteractiveWorkerSession(sessionId) {
+        const session = this.sessionManager.getSession(sessionId);
+        const pluginName = session?.plugin.name;
+        if (!pluginName || (!isClaudeCodeWorker(pluginName) && !isCodexWorker(pluginName))) {
+            return;
+        }
+        for (let attempt = 0; attempt < 24; attempt += 1) {
+            const currentSession = this.sessionManager.getSession(sessionId);
+            if (!currentSession)
+                return;
+            const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+            if (isClaudeCodeWorker(pluginName)) {
+                if (claudeNeedsTrustConfirmation(bufferedOutput)) {
+                    this.sessionManager.sendInput(sessionId, "\r");
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    continue;
+                }
+                if (isClaudeReadyForTask(bufferedOutput)) {
+                    return;
+                }
+            }
+            if (isCodexWorker(pluginName)) {
+                if (codexNeedsTrustConfirmation(bufferedOutput)) {
+                    this.sessionManager.sendInput(sessionId, "\r");
+                    await new Promise((resolve) => setTimeout(resolve, 350));
+                    continue;
+                }
+                if (isCodexReadyForTask(bufferedOutput)) {
+                    return;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+    }
+    async seedClaudeWorkerTask(sessionId, taskSummary) {
+        this.captureWorkerTitleFromInput(sessionId, taskSummary);
+        const result = await this.runClaudeWorkerTurn(sessionId, taskSummary, 90_000);
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        if (worker) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: result.changed ? "result_received" : "waiting_for_result",
+                coordinationTaskSummary: taskSummary,
+                activityState: result.changed ? "ready" : "busy",
+                activityUpdatedAt: Date.now(),
+                lastError: result.changed ? undefined : worker.lastError,
+            });
+        }
+        if (!result.changed) {
+            throw new Error("Claude worker did not produce a fresh result for the initial task");
+        }
+    }
+    async seedCodexWorkerTask(sessionId, taskSummary) {
+        this.captureWorkerTitleFromInput(sessionId, taskSummary);
+        const result = await this.runCodexWorkerTurn(sessionId, taskSummary, 90_000);
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        if (worker) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: result.changed ? "result_received" : "waiting_for_result",
+                coordinationTaskSummary: taskSummary,
+                activityState: result.changed ? "ready" : "busy",
+                activityUpdatedAt: Date.now(),
+                lastError: result.changed ? undefined : worker.lastError,
+            });
+        }
+        if (!result.changed) {
+            throw new Error("Codex worker did not produce a fresh result for the initial task");
+        }
+    }
+    async ensurePrimaryAgent() {
+        const pluginName = this.primaryAgent.pluginName;
+        if (!pluginName) {
+            this.primaryAgent = { ...this.primaryAgent, status: "disabled" };
+            this.broadcastWorkerList();
+            return;
+        }
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin) {
+            this.primaryAgent = { ...this.primaryAgent, status: "missing", lastError: `Plugin not found: ${pluginName}` };
+            this.broadcastWorkerList();
+            return;
+        }
+        if (this.sessionManager.getSession(this.primaryAgent.sessionId)) {
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                status: "running",
+                capabilities: [...plugin.capabilities],
+            };
+            this.broadcastWorkerList();
+            return;
+        }
+        try {
+            const pieSessionId = plugin.name === "pie" ? this.primaryAgent.sessionId : undefined;
+            const primaryPluginBase = {
+                ...plugin,
+                args: pieSessionId
+                    ? [...(plugin.args || []), "--session-id", pieSessionId]
+                    : plugin.args,
+                env: {
+                    ...(plugin.env || {}),
+                    MAGIC_SHELL_RELAY_URL: this.options.relayUrl,
+                    MAGIC_SHELL_NODE_ID: this.options.nodeId,
+                    MAGIC_SHELL_PASSWORD: this.options.password,
+                },
+            };
+            const primaryPlugin = plugin.name === "pie"
+                ? withPrimaryPieExtensionPath(primaryPluginBase)
+                : primaryPluginBase;
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                status: "starting",
+                capabilities: [...plugin.capabilities],
+                lastError: undefined,
+                agentSessionId: pieSessionId || this.primaryAgent.agentSessionId,
+            };
+            if (this.primaryAgent.launchMode === "headless") {
+                this.primaryAgent = {
+                    ...this.primaryAgent,
+                    status: "running",
+                };
+                this.broadcastWorkerList();
+                return;
+            }
+            await this.sessionManager.createSession(this.primaryAgent.sessionId, primaryPlugin);
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                status: "running",
+            };
+        }
+        catch (err) {
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                status: "failed",
+                lastError: err instanceof Error ? err.message : String(err),
+            };
+        }
+        this.broadcastWorkerList();
+    }
+    async handleControlEnvelope(message, source = "relay") {
+        if (message.controlKind === "event" && String(message.controlName || "") === "session.subscription_changed") {
+            const controlMessage = message;
+            const payload = this.readPayloadObject(controlMessage.payload);
+            const sessionId = this.readString(payload.sessionId) || controlMessage.sessionId;
+            const attachedBrowserCount = this.readNumber(payload.attachedBrowserCount) || 0;
+            if (sessionId) {
+                this.updateSessionSubscription(source, sessionId, attachedBrowserCount);
+            }
+            return;
+        }
+        if (message.controlKind === "event") {
+            return;
+        }
+        await this.handleControlMessage(message, source);
+    }
+    async handleControlMessage(message, source = "relay") {
+        if (message.controlKind === "command" && message.controlName) {
+            await this.handleControlCommand(message.controlName, message, source);
+            return;
+        }
+        if (message.controlKind === "query" && message.controlName) {
+            await this.handleControlQuery(message.controlName, message, source);
+            return;
+        }
+        this.sendControlResult(source, message.requestId, message.controlName, false, {
+            error: "Unsupported control message",
+        });
+    }
+    async handleControlCommand(name, message, source = "relay") {
+        const payload = this.readPayloadObject(message.payload);
+        switch (name) {
+            case "spawn_worker": {
+                const pluginName = this.readString(payload.pluginName) || message.pluginName || this.preferredWorkerPluginName || "pie";
+                const taskSummary = this.readString(payload.taskSummary) || message.taskSummary;
+                const cwd = this.readString(payload.cwd) || message.cwd;
+                const displayName = this.readString(payload.displayName) || message.displayName;
+                const sessionId = this.readString(payload.sessionId) || message.target?.sessionId || generateSessionId();
+                try {
+                    await this.spawnWorker({ sessionId, pluginName, cwd, displayName, taskSummary });
+                    if (taskSummary) {
+                        this.rememberNodeSpawn(taskSummary, sessionId);
+                    }
+                    this.sendControlResult(source, message.requestId, name, true, {
+                        sessionId,
+                        pluginName,
+                        displayName: displayName || null,
+                        taskSummary: taskSummary || null,
+                    });
+                }
+                catch (err) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
+            case "set_worker_plugin_preference": {
+                const pluginName = this.readString(payload.pluginName) || message.pluginName;
+                if (!pluginName) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing pluginName" });
+                    return;
+                }
+                if (!this.plugins.has(pluginName)) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: `Unknown plugin: ${pluginName}` });
+                    return;
+                }
+                this.preferredWorkerPluginName = pluginName;
+                this.broadcastWorkerList();
+                this.sendControlResult(source, message.requestId, name, true, { pluginName });
+                return;
+            }
+            case "attach_session": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                if (!sessionId) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use send_primary_message instead of attach_session.",
+                    });
+                    return;
+                }
+                const responses = attachWorkerSession(sessionId, {
+                    workerRegistry: this.workerRegistry,
+                    sessionManager: this.sessionManager,
+                });
+                for (const response of responses) {
+                    this.sendToSource(source, response);
+                }
+                this.sendControlResult(source, message.requestId, name, true, { sessionId });
+                this.sendToSource(source, {
+                    type: "control",
+                    controlKind: "event",
+                    controlName: "session.attached",
+                    payload: { sessionId },
+                    sessionId,
+                });
+                return;
+            }
+            case "stop_worker": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                if (!sessionId) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId" });
+                    return;
+                }
+                await stopWorkerSession(sessionId, {
+                    workerRegistry: this.workerRegistry,
+                    sessionManager: this.sessionManager,
+                    clearSessionTitle: (nextSessionId) => {
+                        this.sessionTitleBuffers.delete(nextSessionId);
+                    },
+                    broadcastWorkerList: () => {
+                        this.broadcastWorkerList();
+                    },
+                    spawnWorker: (options) => this.spawnWorker(options),
+                });
+                this.sendControlResult(source, message.requestId, name, true, { sessionId });
+                return;
+            }
+            case "restart_worker": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                if (!sessionId) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId" });
+                    return;
+                }
+                const error = await restartWorkerSession(sessionId, {
+                    workerRegistry: this.workerRegistry,
+                    sessionManager: this.sessionManager,
+                    clearSessionTitle: (nextSessionId) => {
+                        this.sessionTitleBuffers.delete(nextSessionId);
+                    },
+                    broadcastWorkerList: () => {
+                        this.broadcastWorkerList();
+                    },
+                    spawnWorker: (options) => this.spawnWorker(options),
+                });
+                if (error) {
+                    this.sendControlResult(source, message.requestId, name, false, { error });
+                    return;
+                }
+                this.sendControlResult(source, message.requestId, name, true, { sessionId });
+                return;
+            }
+            case "send_input": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId) || message.sessionId;
+                const data = this.readString(payload.data) || message.data;
+                if (!sessionId || !data) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId or data" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use send_primary_message instead of send_input.",
+                    });
+                    return;
+                }
+                this.captureWorkerTitleFromInput(sessionId, data);
+                this.sessionManager.sendInput(sessionId, data);
+                this.sendControlResult(source, message.requestId, name, true, { sessionId });
+                return;
+            }
+            case "send_to_session": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId) || message.sessionId;
+                const data = this.readString(payload.message) || this.readString(payload.data) || message.data;
+                const mode = this.readString(payload.mode) || "follow_up";
+                if (!sessionId || !data) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId or message" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use send_primary_message instead of send_to_session.",
+                    });
+                    return;
+                }
+                this.captureWorkerTitleFromInput(sessionId, data);
+                this.sessionManager.sendInput(sessionId, this.formatSessionControlInput(data));
+                this.sendControlResult(source, message.requestId, name, true, { sessionId, mode, message: data });
+                return;
+            }
+            case "session_turn": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId) || message.sessionId;
+                const data = this.readString(payload.message) || this.readString(payload.data) || message.data;
+                const mode = this.readString(payload.mode) || "follow_up";
+                const timeoutMs = this.readNumber(payload.timeoutMs) || 8000;
+                const pollIntervalMs = this.readNumber(payload.pollIntervalMs) || 250;
+                if (!sessionId || !data) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId or message" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use send_primary_message instead of session_turn.",
+                    });
+                    return;
+                }
+                const result = await this.runSessionTurn(sessionId, data, {
+                    mode,
+                    timeoutMs,
+                    pollIntervalMs,
+                });
+                this.sendControlResult(source, message.requestId, name, true, result);
+                return;
+            }
+            case "send_primary_message": {
+                const text = this.readString(payload.text) || message.text;
+                if (!text) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing text" });
+                    return;
+                }
+                const response = await this.handlePrimaryMessage(text);
+                this.sendControlResult(source, message.requestId, name, true, response);
+                this.sendServerMessage({
+                    type: "control",
+                    controlKind: "event",
+                    controlName: "node.reply",
+                    payload: response,
+                });
+                return;
+            }
+            case "resize_session": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId) || message.sessionId;
+                const cols = this.readNumber(payload.cols) || message.cols;
+                const rows = this.readNumber(payload.rows) || message.rows;
+                if (!sessionId || !cols || !rows) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId, cols, or rows" });
+                    return;
+                }
+                this.sessionManager.resize(sessionId, cols, rows);
+                this.sendControlResult(source, message.requestId, name, true, { sessionId, cols, rows });
+                return;
+            }
+        }
+    }
+    async handleControlQuery(name, message, source = "relay") {
+        const payload = this.readPayloadObject(message.payload);
+        switch (name) {
+            case "get_runtime_summary":
+            case "list_workers":
+                this.sendControlResult(source, message.requestId, name, true, this.buildRuntimeSnapshot());
+                return;
+            case "get_worker_detail": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                const agentId = message.target?.agentId || this.readString(payload.agentId);
+                const worker = sessionId
+                    ? this.workerRegistry.getWorkerBySessionId(sessionId)
+                    : agentId
+                        ? this.workerRegistry.getWorkerByAgentId(agentId)
+                        : undefined;
+                if (!worker) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Worker not found" });
+                    return;
+                }
+                const detail = this.workerRegistry.getWorkerDetail(worker.agentId, this.getWorkerOutputSummary(worker.sessionId));
+                if (!detail) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Worker detail unavailable" });
+                    return;
+                }
+                this.sendControlResult(source, message.requestId, name, true, { worker: detail });
+                this.sendServerMessage({
+                    type: "control",
+                    controlKind: "event",
+                    controlName: "worker.detail",
+                    payload: { worker: detail },
+                    sessionId: worker.sessionId,
+                });
+                return;
+            }
+            case "get_session_message": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                if (!sessionId) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use get_primary_agent instead of get_session_message.",
+                    });
+                    return;
+                }
+                const pieSnapshot = this.sessionManager.getSession(sessionId)?.plugin.name === "pie"
+                    ? readPieSessionSnapshot(sessionId)
+                    : null;
+                const lastMessage = pieSnapshot?.lastAssistantText || this.getWorkerOutputMessage(sessionId);
+                this.sendControlResult(source, message.requestId, name, true, {
+                    sessionId,
+                    message: lastMessage || null,
+                });
+                return;
+            }
+            case "get_session_summary": {
+                const sessionId = message.target?.sessionId || this.readString(payload.sessionId);
+                if (!sessionId) {
+                    this.sendControlResult(source, message.requestId, name, false, { error: "Missing sessionId" });
+                    return;
+                }
+                if (this.isProtectedPrimarySession(sessionId)) {
+                    this.sendControlResult(source, message.requestId, name, false, {
+                        error: "Primary session is protected. Use get_primary_agent instead of get_session_summary.",
+                    });
+                    return;
+                }
+                const pieSnapshot = this.sessionManager.getSession(sessionId)?.plugin.name === "pie"
+                    ? readPieSessionSnapshot(sessionId)
+                    : null;
+                const summary = pieSnapshot?.lastAssistantText || this.getWorkerOutputSummary(sessionId);
+                this.sendControlResult(source, message.requestId, name, true, {
+                    sessionId,
+                    summary: summary || null,
+                });
+                return;
+            }
+            case "get_primary_agent": {
+                this.sendControlResult(source, message.requestId, name, true, {
+                    primary: this.buildPrimaryAgentStatus(),
+                });
+                return;
+            }
+            case "browse_directories": {
+                const response = await buildDirectoryList(message.target?.path || this.readString(payload.path) || message.path);
+                this.sendControlResult(source, message.requestId, name, true, {
+                    path: response.path || null,
+                    parentPath: response.parentPath || null,
+                    repoRoot: response.repoRoot || null,
+                    entries: response.entries || [],
+                });
+                this.sendServerMessage({
+                    type: "control",
+                    controlKind: "event",
+                    controlName: "directory.list",
+                    payload: {
+                        path: response.path || null,
+                        parentPath: response.parentPath || null,
+                        repoRoot: response.repoRoot || null,
+                        entries: response.entries || [],
+                    },
+                });
+                return;
+            }
+        }
+    }
+    sendControlResult(source = "relay", requestId, controlName, ok, payload) {
+        this.sendToSource(source, {
+            type: "control",
+            controlKind: "result",
+            controlName,
+            requestId,
+            ok,
+            payload,
+        });
+    }
+    buildRuntimeSnapshot() {
+        return {
+            nodeId: this.options.nodeId,
+            workers: this.workerRegistry.listWorkers(),
+            runtime: this.workerRegistry.getRuntimeSummary(),
+            focus: this.workerRegistry.getRuntimeFocus(),
+            primary: this.buildPrimaryAgentStatus(),
+            nodeHistory: this.nodeConversation.history,
+        };
+    }
+    buildPrimaryAgentStatus() {
+        return {
+            pluginName: this.primaryAgent.pluginName,
+            preferredWorkerPluginName: this.preferredWorkerPluginName,
+            sessionId: this.primaryAgent.sessionId,
+            status: this.primaryAgent.status,
+            activityState: this.primaryAgent.activityState,
+            lastError: this.primaryAgent.lastError,
+            capabilities: this.primaryAgent.capabilities || [],
+        };
+    }
+    isProtectedPrimarySession(sessionId) {
+        return !!sessionId && sessionId === this.primaryAgent.sessionId;
+    }
+    async runSessionTurn(sessionId, message, options) {
+        const session = this.sessionManager.getSession(sessionId);
+        const isPieSession = session?.plugin.name === "pie";
+        const isClaudeSession = isClaudeCodeWorker(session?.plugin.name);
+        const isCodexSession = isCodexWorker(session?.plugin.name);
+        let usePieSessionControl = isPieSession;
+        const beforeOutput = this.sessionManager.getBufferedOutput(sessionId);
+        const previousMessage = getLastMeaningfulWorkerMessage(beforeOutput) || "";
+        const previousSummary = summarizeRecentWorkerOutput(beforeOutput) || "";
+        const pieSessionBefore = isPieSession ? readPieSessionSnapshot(sessionId) : null;
+        const pieControlBefore = isPieSession ? readPieSessionControlState(sessionId) : null;
+        const terminalInput = this.formatSessionControlInput(message);
+        const startedAt = Date.now();
+        const requestId = `ms-${startedAt}-${Math.random().toString(36).slice(2, 8)}`;
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        this.captureWorkerTitleFromInput(sessionId, message);
+        if (worker) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: "delegating",
+                coordinationTaskSummary: message,
+                activityState: "busy",
+                activityUpdatedAt: startedAt,
+            });
+            this.broadcastWorkerList();
+        }
+        if (isPieSession) {
+            writePieSessionControlCommand(sessionId, {
+                requestId,
+                message,
+                mode: options.mode === "steer" ? "steer" : "follow_up",
+                createdAt: startedAt,
+                status: "pending",
+            });
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (!readPieSessionControlState(sessionId)) {
+                usePieSessionControl = false;
+                this.sessionManager.sendInput(sessionId, terminalInput);
+            }
+        }
+        else if (isClaudeSession) {
+            const claudeResult = await this.runClaudeWorkerTurn(sessionId, message, options.timeoutMs);
+            if (worker) {
+                this.workerRegistry.updateWorker(worker.agentId, {
+                    coordinationState: claudeResult.changed ? "result_received" : "waiting_for_result",
+                    coordinationTaskSummary: message,
+                    activityState: claudeResult.changed ? "ready" : "busy",
+                    activityUpdatedAt: Date.now(),
+                    lastError: claudeResult.changed ? undefined : worker.lastError,
+                });
+                this.broadcastWorkerList();
+            }
+            return {
+                sessionId,
+                mode: options.mode,
+                message: claudeResult.message || null,
+                summary: claudeResult.summary || null,
+                changed: claudeResult.changed,
+                timedOut: claudeResult.timedOut,
+            };
+        }
+        else if (isCodexSession) {
+            const codexResult = await this.runCodexWorkerTurn(sessionId, message, options.timeoutMs);
+            if (worker) {
+                this.workerRegistry.updateWorker(worker.agentId, {
+                    coordinationState: codexResult.changed ? "result_received" : "waiting_for_result",
+                    coordinationTaskSummary: message,
+                    activityState: codexResult.changed ? "ready" : "busy",
+                    activityUpdatedAt: Date.now(),
+                    lastError: codexResult.changed ? undefined : worker.lastError,
+                });
+                this.broadcastWorkerList();
+            }
+            return {
+                sessionId,
+                mode: options.mode,
+                message: codexResult.message || null,
+                summary: codexResult.summary || null,
+                changed: codexResult.changed,
+                timedOut: codexResult.timedOut,
+            };
+        }
+        else {
+            this.sessionManager.sendInput(sessionId, terminalInput);
+        }
+        if (worker && !isPieSession) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: "waiting_for_result",
+                coordinationTaskSummary: message,
+                activityState: "busy",
+                activityUpdatedAt: Date.now(),
+            });
+            this.broadcastWorkerList();
+        }
+        const deadline = startedAt + Math.max(options.timeoutMs, 250);
+        const pollIntervalMs = Math.max(options.pollIntervalMs, 25);
+        let latestMessage = previousMessage;
+        let latestSummary = previousSummary;
+        let changed = false;
+        while (Date.now() <= deadline) {
+            if (usePieSessionControl) {
+                const pieControlAfter = readPieSessionControlState(sessionId);
+                if (pieControlAfter
+                    && pieControlAfter.lastCompletedRequestId === requestId
+                    && pieControlAfter.lastAssistantText
+                    && pieControlAfter.lastAssistantText !== pieControlBefore?.lastAssistantText
+                    && this.isUsablePieSessionTurnResult(pieControlAfter.lastAssistantText, message)) {
+                    latestMessage = pieControlAfter.lastAssistantText;
+                    latestSummary = pieControlAfter.lastAssistantText;
+                    changed = true;
+                    break;
+                }
+            }
+            const pieSessionAfter = isPieSession ? readPieSessionSnapshot(sessionId) : null;
+            if (pieSessionAfter
+                && pieSessionAfter.messageCount > (pieSessionBefore?.messageCount || 0)
+                && pieSessionAfter.lastAssistantText
+                && pieSessionAfter.lastAssistantText !== pieSessionBefore?.lastAssistantText
+                && pieSessionAfter.lastMessageRole === "assistant"
+                && !pieSessionAfter.lastAssistantHasToolCall
+                && Date.now() - pieSessionAfter.updatedAt >= 500) {
+                if (this.isUsablePieSessionTurnResult(pieSessionAfter.lastAssistantText, message)) {
+                    latestMessage = pieSessionAfter.lastAssistantText;
+                    latestSummary = pieSessionAfter.lastAssistantText;
+                    changed = true;
+                    break;
+                }
+            }
+            if (!isPieSession) {
+                const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+                latestMessage = getLastMeaningfulWorkerMessage(bufferedOutput) || "";
+                latestSummary = summarizeRecentWorkerOutput(bufferedOutput) || "";
+                changed = (!!latestMessage && latestMessage !== previousMessage)
+                    || (!!latestSummary && latestSummary !== previousSummary);
+                if (changed
+                    && this.isLikelyEchoedSessionInput(latestMessage, latestSummary, message)) {
+                    changed = false;
+                }
+                if (changed) {
+                    break;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        if (worker) {
+            this.workerRegistry.updateWorker(worker.agentId, {
+                coordinationState: changed ? "result_received" : "waiting_for_result",
+                coordinationTaskSummary: message,
+                activityState: changed ? "ready" : "busy",
+                activityUpdatedAt: Date.now(),
+                lastError: changed ? undefined : worker.lastError,
+            });
+            this.broadcastWorkerList();
+        }
+        return {
+            sessionId,
+            mode: options.mode,
+            message: latestMessage || null,
+            summary: latestSummary || null,
+            changed,
+            timedOut: !changed,
+        };
+    }
+    async runClaudeWorkerTurn(sessionId, message, timeoutMs) {
+        const session = this.sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Claude worker session not found: ${sessionId}`);
+        }
+        const cwd = session.plugin.cwd || this.workerRegistry.getWorkerBySessionId(sessionId)?.cwd || process.cwd();
+        const beforeOutput = this.sessionManager.getBufferedOutput(sessionId);
+        const previousSummary = summarizeClaudeWorkerOutput(beforeOutput, message);
+        try {
+            const result = await runClaudeExec({
+                cwd,
+                message,
+                timeoutMs,
+            });
+            this.syntheticSessionResults.set(sessionId, {
+                message: result.message,
+                summary: result.summary,
+                updatedAt: Date.now(),
+            });
+            if (result.summary) {
+                this.sessionManager.appendOutput(sessionId, `${result.summary}\n`);
+            }
+            return {
+                message: result.message,
+                summary: result.summary,
+                changed: !!result.summary,
+                timedOut: false,
+            };
+        }
+        catch (error) {
+            const code = typeof error === "object" && error && "code" in error ? String(error.code || "") : "";
+            if (code === "CLAUDE_EXEC_TIMEOUT") {
+                return {
+                    message: "",
+                    summary: previousSummary,
+                    changed: false,
+                    timedOut: true,
+                };
+            }
+            throw error;
+        }
+    }
+    async runCodexWorkerTurn(sessionId, message, timeoutMs) {
+        const session = this.sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Codex worker session not found: ${sessionId}`);
+        }
+        const cwd = session.plugin.cwd || this.workerRegistry.getWorkerBySessionId(sessionId)?.cwd || process.cwd();
+        const beforeOutput = this.sessionManager.getBufferedOutput(sessionId);
+        const previousSummary = summarizeCodexWorkerOutput(beforeOutput, message);
+        try {
+            const result = await runCodexExec({
+                cwd,
+                message,
+                timeoutMs,
+            });
+            this.syntheticSessionResults.set(sessionId, {
+                message: result.message,
+                summary: result.summary,
+                updatedAt: Date.now(),
+            });
+            if (result.summary) {
+                this.sessionManager.appendOutput(sessionId, `${result.summary}\n`);
+            }
+            return {
+                message: result.message,
+                summary: result.summary,
+                changed: !!result.summary,
+                timedOut: false,
+            };
+        }
+        catch (error) {
+            const code = typeof error === "object" && error && "code" in error ? String(error.code || "") : "";
+            if (code === "CODEX_EXEC_TIMEOUT") {
+                return {
+                    message: "",
+                    summary: previousSummary,
+                    changed: false,
+                    timedOut: true,
+                };
+            }
+            throw error;
+        }
+    }
+    isLikelyEchoedSessionInput(message, summary, input) {
+        const normalize = (value) => stripAnsi(value || "").replace(/\s+/g, " ").trim();
+        const normalizedInput = normalize(input);
+        if (!normalizedInput)
+            return false;
+        const candidates = [normalize(message), normalize(summary)].filter(Boolean);
+        if (!candidates.length)
+            return false;
+        return candidates.every((candidate) => {
+            if (!candidate)
+                return true;
+            if (normalizedInput.includes(candidate) || candidate.includes(normalizedInput)) {
+                return true;
+            }
+            const prefix = normalizedInput.slice(0, Math.min(normalizedInput.length, 80));
+            return prefix.length >= 24 && candidate.includes(prefix.slice(0, 24));
+        });
+    }
+    isUsablePieSessionTurnResult(text, input) {
+        const normalized = stripAnsi(text || "").replace(/\s+/g, " ").trim();
+        if (!normalized) {
+            return false;
+        }
+        if (this.isLikelyEchoedSessionInput(normalized, normalized, input)) {
+            return false;
+        }
+        const lowered = normalized.toLowerCase();
+        if (lowered.includes("queued message for")
+            || lowered.includes("message_update")
+            || lowered.includes("looks ready for input")
+            || lowered.includes("work in your own session")
+            || lowered.includes("reply to the primary agent now")
+            || lowered.startsWith("the user asked me")
+            || normalized.startsWith("用户要求我")
+            || lowered.includes("please tell me the specific task")
+            || lowered.includes("tell me the specific task")
+            || lowered.includes("what would you like me to do")
+            || lowered.includes("what do you want me to do")
+            || normalized.includes("请告诉我具体任务")
+            || normalized.includes("请告诉我具体想做什么")
+            || normalized.includes("你想派 worker 去干什么")) {
+            return false;
+        }
+        return true;
+    }
+    getWorkerOutputSummary(sessionId) {
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        const syntheticResult = this.syntheticSessionResults.get(sessionId);
+        if (worker && (isClaudeCodeWorker(worker.agentType) || isCodexWorker(worker.agentType)) && syntheticResult?.summary) {
+            return syntheticResult.summary;
+        }
+        const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+        if (worker && isClaudeCodeWorker(worker.agentType)) {
+            return summarizeClaudeWorkerOutput(bufferedOutput, worker.coordinationTaskSummary || worker.taskSummary || "");
+        }
+        if (worker && isCodexWorker(worker.agentType)) {
+            return summarizeCodexWorkerOutput(bufferedOutput, worker.coordinationTaskSummary || worker.taskSummary || "");
+        }
+        return summarizeRecentWorkerOutput(bufferedOutput);
+    }
+    getWorkerOutputMessage(sessionId) {
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        const syntheticResult = this.syntheticSessionResults.get(sessionId);
+        if (worker && (isClaudeCodeWorker(worker.agentType) || isCodexWorker(worker.agentType)) && syntheticResult?.message) {
+            return syntheticResult.message;
+        }
+        const bufferedOutput = this.sessionManager.getBufferedOutput(sessionId);
+        if (worker && isClaudeCodeWorker(worker.agentType)) {
+            return getLastClaudeWorkerMessage(bufferedOutput, worker.coordinationTaskSummary || worker.taskSummary || "");
+        }
+        if (worker && isCodexWorker(worker.agentType)) {
+            return getLastCodexWorkerMessage(bufferedOutput, worker.coordinationTaskSummary || worker.taskSummary || "");
+        }
+        return getLastMeaningfulWorkerMessage(bufferedOutput);
+    }
+    readString(value) {
+        return typeof value === "string" && value.trim() ? value : undefined;
+    }
+    readNumber(value) {
+        return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    }
+    readPayloadObject(value) {
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    recordPrimaryOutput(content) {
+        const metadata = extractTerminalMetadata(content, this.primaryAgent.pluginName);
+        this.primaryAgent = {
+            ...this.primaryAgent,
+            status: "running",
+            lastOutputAt: Date.now(),
+            title: metadata?.title || this.primaryAgent.title,
+            activityState: metadata?.activityState || this.primaryAgent.activityState,
+            agentSessionId: metadata?.agentSessionId || this.primaryAgent.agentSessionId,
+        };
+        if (metadata) {
+            this.broadcastWorkerList();
+        }
+    }
+    captureWorkerTitleFromInput(sessionId, data) {
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        if (!worker || worker.taskSummary) {
+            return;
+        }
+        let buffer = this.sessionTitleBuffers.get(sessionId) || "";
+        for (const char of data) {
+            if (char === "\u001b") {
+                return;
+            }
+            if (char === "\u007f" || char === "\b") {
+                buffer = buffer.slice(0, -1);
+                continue;
+            }
+            if (char === "\r" || char === "\n") {
+                const title = normalizeWorkerTitleCandidate(buffer);
+                if (title) {
+                    this.workerRegistry.updateWorker(worker.agentId, { taskSummary: title });
+                    this.broadcastWorkerList();
+                    this.sessionTitleBuffers.delete(sessionId);
+                    return;
+                }
+                buffer = "";
+                continue;
+            }
+            if (char >= " " && char !== "\u007f") {
+                buffer += char;
+            }
+        }
+        this.sessionTitleBuffers.set(sessionId, buffer.slice(-256));
+    }
+    broadcastWorkerList() {
+        const snapshot = this.buildRuntimeSnapshot();
+        this.sendServerMessage({
+            type: "worker_list",
+            workers: snapshot.workers,
+            runtime: snapshot.runtime,
+            focus: snapshot.focus,
+            primary: snapshot.primary,
+            nodeHistory: snapshot.nodeHistory,
+        });
+        this.sendServerMessage({
+            type: "control",
+            controlKind: "event",
+            controlName: "runtime.snapshot",
+            payload: snapshot,
+        });
+    }
+    rememberNodeSpawn(taskSummary, sessionId) {
+        const worker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        this.nodeConversation = rememberNodeSpawn(this.nodeConversation, taskSummary, sessionId, worker);
+    }
+    async handlePrimaryMessage(text) {
+        const userText = text.trim();
+        this.nodeConversation.lastUserMessage = userText;
+        this.recordConversationTurn("user", userText);
+        const orchestrated = await this.tryHandlePrimaryOrchestration(userText);
+        if (orchestrated) {
+            this.recordConversationTurn("assistant", orchestrated.text, {
+                actionType: orchestrated.actionType,
+                actionLabel: orchestrated.actionLabel,
+                actionTaskSummary: orchestrated.actionTaskSummary,
+                actionSessionId: orchestrated.actionSessionId,
+            });
+            return orchestrated;
+        }
+        try {
+            const primaryText = await this.queryPrimarySessionText(userText);
+            if (primaryText?.trim()) {
+                const response = {
+                    text: primaryText.trim(),
+                };
+                this.recordConversationTurn("assistant", response.text);
+                return response;
+            }
+            throw new Error("Primary session did not return a visible assistant message");
+        }
+        catch (err) {
+            this.primaryAgent = {
+                ...this.primaryAgent,
+                lastError: err instanceof Error ? err.message : String(err),
+            };
+            this.broadcastWorkerList();
+            const response = {
+                text: `Primary agent unavailable: ${this.primaryAgent.lastError}`,
+            };
+            this.recordConversationTurn("assistant", response.text);
+            return response;
+        }
+    }
+    async tryHandlePrimaryOrchestration(userText) {
+        const spawnIntent = this.parseSpawnWorkerIntent(userText);
+        if (spawnIntent) {
+            return this.handleSpawnWorkerIntent(spawnIntent);
+        }
+        const stopName = this.parseNamedWorkerAction(userText, /(停止|停掉|stop)\s*([^\s，。,.]+)/i);
+        if (stopName) {
+            return this.handleStopWorkerIntent(stopName);
+        }
+        const restartName = this.parseNamedWorkerAction(userText, /(重启|restart)\s*([^\s，。,.]+)/i);
+        if (restartName) {
+            return this.handleRestartWorkerIntent(restartName, userText);
+        }
+        if (/现在有哪些\s*worker|who.*alive|谁还活着|谁停了/u.test(userText)) {
+            return this.handleWorkerRosterIntent();
+        }
+        if (/第一个\s*worker.*README.*第二个\s*worker.*git commit/u.test(userText)) {
+            return this.handleOrdinalMultiWorkerIntent();
+        }
+        if (/小明和小美.*git.*汇总/u.test(userText)) {
+            return this.handleNamedMultiWorkerCommitIntent(["小明", "小美"]);
+        }
+        const readmeTarget = this.parseNamedWorkerTaskIntent(userText, /让\s*([^\s，。,.]+)\s*(?:读一下|检查|看看).*(README|readme)/u);
+        if (readmeTarget) {
+            return this.handleWorkerTaskIntent(readmeTarget.workerName, "请在当前仓库读取 README，并用中文给出简洁但具体的摘要。");
+        }
+        const inspectTarget = this.parseNamedWorkerTaskIntent(userText, /让\s*([^\s，。,.]+)\s*看一下当前目录有什么/u);
+        if (inspectTarget) {
+            return this.handleWorkerTaskIntent(inspectTarget.workerName, "请列出当前目录里最重要的文件和目录，并用中文简洁总结它们是做什么的。");
+        }
+        return null;
+    }
+    parseSpawnWorkerIntent(userText) {
+        const workerName = this.parseWorkerName(userText) || this.lastFailedNamedWorker;
+        if (/(spawn 一个 worker|来一个|创建.*worker|新建.*worker)/u.test(userText)
+            || (/去\s*.+目录/u.test(userText) && /worker/u.test(userText))) {
+            const cwdText = this.extractPathFragment(userText);
+            if (cwdText) {
+                return { cwdText, workerName: workerName || undefined };
+            }
+        }
+        if (workerName && /(在|去).*(codex|token-manager|not-exist-project|AIProjects)/iu.test(userText)) {
+            const cwdText = this.extractPathFragment(userText);
+            if (cwdText) {
+                return { cwdText, workerName };
+            }
+        }
+        return null;
+    }
+    parseWorkerName(userText) {
+        const explicit = userText.match(/叫\s*([^，。,.]+)/u)?.[1];
+        if (explicit)
+            return explicit.trim();
+        const implied = userText.match(/(?:再?来一个|来个)\s*([^\s，在去让把帮给，。,.]+)/u)?.[1];
+        if (implied)
+            return implied.trim();
+        return null;
+    }
+    extractPathFragment(userText) {
+        const absolute = userText.match(/(\/Users\/[^\s，。]+)/u)?.[1];
+        if (absolute)
+            return absolute;
+        const homeNamed = userText.match(/\b(Documents|Desktop|Downloads)\b/i)?.[1];
+        if (homeNamed)
+            return homeNamed;
+        const named = userText.match(/\b(codex|token-manager|not-exist-project)\b/i)?.[1];
+        if (named)
+            return named;
+        if (/AIProjects.*token-manager/i.test(userText))
+            return "token-manager";
+        if (/AIProjects.*codex/i.test(userText))
+            return "codex";
+        return null;
+    }
+    resolveWorkerCwd(cwdText) {
+        if (!cwdText)
+            return null;
+        if (cwdText.startsWith("/")) {
+            return existsSync(cwdText) ? cwdText : null;
+        }
+        const homeCandidate = path.join(os.homedir(), cwdText);
+        if (existsSync(homeCandidate)) {
+            return homeCandidate;
+        }
+        const aiProjectsRoot = path.resolve(process.cwd(), "..");
+        const candidate = path.join(aiProjectsRoot, cwdText);
+        return existsSync(candidate) ? candidate : null;
+    }
+    async handleSpawnWorkerIntent(intent) {
+        const resolvedCwd = this.resolveWorkerCwd(intent.cwdText);
+        if (!resolvedCwd) {
+            this.lastFailedNamedWorker = intent.workerName;
+            return {
+                text: `${intent.workerName ? `${intent.workerName} ` : ""}目标目录不存在或当前节点无法访问：${intent.cwdText}`,
+            };
+        }
+        const sessionId = generateSessionId();
+        await this.spawnWorker({
+            sessionId,
+            pluginName: this.preferredWorkerPluginName,
+            cwd: resolvedCwd,
+            displayName: intent.workerName,
+        });
+        this.lastFailedNamedWorker = undefined;
+        this.rememberNodeSpawn(`Inspect ${path.basename(resolvedCwd)}`, sessionId);
+        this.broadcastWorkerList();
+        return {
+            text: `${intent.workerName || "新 worker"} 已创建，目录是 \`${resolvedCwd}\`。`,
+            actionType: "attach",
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: sessionId,
+        };
+    }
+    parseNamedWorkerAction(userText, pattern) {
+        const match = userText.match(pattern);
+        const raw = match?.[2]?.trim();
+        if (!raw)
+            return null;
+        return raw.split(/(?:并|然后|再|,|，|。|\s)/u)[0]?.trim() || null;
+    }
+    parseNamedWorkerTaskIntent(userText, pattern) {
+        const match = userText.match(pattern);
+        if (!match?.[1])
+            return null;
+        return { workerName: match[1].trim() };
+    }
+    findWorkerByName(name) {
+        const normalized = name.trim().toLowerCase();
+        return this.workerRegistry.listWorkers().find((worker) => (worker.displayName || "").trim().toLowerCase() === normalized);
+    }
+    getOrderedLiveWorkers() {
+        return this.workerRegistry
+            .listWorkers()
+            .filter((worker) => worker.status !== "stopped" && worker.status !== "failed")
+            .sort((a, b) => a.createdAt - b.createdAt);
+    }
+    async handleStopWorkerIntent(workerName) {
+        const worker = this.findWorkerByName(workerName);
+        if (!worker) {
+            return { text: `没有找到名为 ${workerName} 的 worker。` };
+        }
+        await stopWorkerSession(worker.sessionId, {
+            workerRegistry: this.workerRegistry,
+            sessionManager: this.sessionManager,
+            clearSessionTitle: (sessionId) => this.sessionTitleBuffers.delete(sessionId),
+            broadcastWorkerList: () => this.broadcastWorkerList(),
+            spawnWorker: (options) => this.spawnWorker(options),
+        });
+        return { text: `${workerName} 已停止。` };
+    }
+    async handleRestartWorkerIntent(workerName, userText) {
+        const worker = this.findWorkerByName(workerName);
+        if (!worker) {
+            return { text: `没有找到名为 ${workerName} 的 worker。` };
+        }
+        const error = await restartWorkerSession(worker.sessionId, {
+            workerRegistry: this.workerRegistry,
+            sessionManager: this.sessionManager,
+            clearSessionTitle: (sessionId) => this.sessionTitleBuffers.delete(sessionId),
+            broadcastWorkerList: () => this.broadcastWorkerList(),
+            spawnWorker: (options) => this.spawnWorker(options),
+        });
+        if (error) {
+            return { text: `${workerName} 重启失败：${error}` };
+        }
+        if (/README|readme/.test(userText)) {
+            return this.handleWorkerTaskIntent(workerName, "请在当前仓库读取 README，并用中文给出简洁但具体的摘要。");
+        }
+        return { text: `${workerName} 已重启。` };
+    }
+    async handleWorkerTaskIntent(workerName, task) {
+        const worker = this.findWorkerByName(workerName);
+        if (!worker) {
+            return { text: `没有找到名为 ${workerName} 的 worker。` };
+        }
+        const result = await this.runSessionTurn(worker.sessionId, task, {
+            mode: "steer",
+            timeoutMs: 90_000,
+            pollIntervalMs: 500,
+        });
+        const answer = result.message || result.summary || "(worker 没有返回可用结果)";
+        return {
+            text: `${workerName} 的结果：\n${answer}`,
+            actionType: "attach",
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: worker.sessionId,
+        };
+    }
+    async handleOrdinalMultiWorkerIntent() {
+        const workers = this.getOrderedLiveWorkers();
+        if (workers.length < 2) {
+            return { text: "当前没有足够的 live workers 来完成这个双 worker 协作请求。" };
+        }
+        const first = workers[0];
+        const second = workers[1];
+        const readme = await this.runSessionTurn(first.sessionId, "请读取当前仓库的 README，并用中文给出简洁摘要。", {
+            mode: "steer",
+            timeoutMs: 90_000,
+            pollIntervalMs: 500,
+        });
+        const commits = await this.runSessionTurn(second.sessionId, "请统计当前 git 仓库一共有多少次 commit，只给出数字和一句简短说明。", {
+            mode: "steer",
+            timeoutMs: 90_000,
+            pollIntervalMs: 500,
+        });
+        return {
+            text: [
+                `${first.displayName || first.sessionId} (${path.basename(first.cwd)}):`,
+                readme.message || readme.summary || "(没有拿到 README 结果)",
+                "",
+                `${second.displayName || second.sessionId} (${path.basename(second.cwd)}):`,
+                commits.message || commits.summary || "(没有拿到 commit 统计结果)",
+            ].join("\n"),
+        };
+    }
+    async handleNamedMultiWorkerCommitIntent(names) {
+        const parts = [];
+        for (const name of names) {
+            const worker = this.findWorkerByName(name);
+            if (!worker) {
+                parts.push(`${name}: 没找到对应 worker。`);
+                continue;
+            }
+            const result = await this.runSessionTurn(worker.sessionId, "请统计当前 git 仓库一共有多少次 commit，只给出数字和一句简短说明。", {
+                mode: "steer",
+                timeoutMs: 90_000,
+                pollIntervalMs: 500,
+            });
+            parts.push(`${name} (${path.basename(worker.cwd)}):\n${result.message || result.summary || "(没有拿到结果)"}`);
+        }
+        return { text: parts.join("\n\n") };
+    }
+    handleWorkerRosterIntent() {
+        const workers = this.workerRegistry.listWorkers().sort((a, b) => a.createdAt - b.createdAt);
+        if (!workers.length) {
+            return { text: "当前没有 workers。" };
+        }
+        return {
+            text: workers.map((worker) => {
+                const status = worker.status === "stopped" || worker.status === "failed" ? "已停止" : "运行中";
+                return `${worker.displayName || worker.sessionId}: ${worker.cwd} · ${status}`;
+            }).join("\n"),
+        };
+    }
+    async ensureSessionForInteractiveMessage(sessionId, reason) {
+        if (this.sessionManager.getSession(sessionId)) {
+            return;
+        }
+        if (this.workerRegistry.getWorkerBySessionId(sessionId)) {
+            console.warn(`[AgentNode] Ignoring ${reason} for inactive worker session: ${sessionId}`);
+            return;
+        }
+        if (!this.plugins.has("pie")) {
+            return;
+        }
+        try {
+            await this.createSession(sessionId, "pie");
+            console.log(`[AgentNode] Created pie session for ${reason}: ${sessionId}`);
+        }
+        catch (err) {
+            console.error(`[AgentNode] Failed to create session for ${reason}:`, err);
+        }
+    }
+    handleSessionOutput(sessionId, output) {
+        if (sessionId === this.primaryAgent.sessionId) {
+            this.recordPrimaryOutput(output.content);
+            return;
+        }
+        const existingWorker = this.workerRegistry.getWorkerBySessionId(sessionId);
+        const previousWorker = existingWorker ? { ...existingWorker } : undefined;
+        const worker = existingWorker
+            ? this.workerRegistry.recordOutputActivity(existingWorker.agentId, output.content.length)
+            : undefined;
+        let sawTerminalMetadata = false;
+        if (worker) {
+            if (output.content.trim()) {
+                this.workerRegistry.recordEvent(worker.agentId, {
+                    type: "output",
+                    timestamp: Date.now(),
+                    message: `output ${output.content.length} chars`,
+                });
+            }
+            console.log(`[AgentNode] Worker ${worker.agentId} output at ${worker.lastOutputAt}`);
+            const terminalMetadata = extractTerminalMetadata(output.content, worker.agentType);
+            if (terminalMetadata) {
+                sawTerminalMetadata = true;
+                const updates = {};
+                if (terminalMetadata.title && !worker.taskSummary) {
+                    updates.taskSummary = terminalMetadata.title;
+                }
+                if (terminalMetadata.activityState && terminalMetadata.activityState !== worker.activityState) {
+                    updates.activityState = terminalMetadata.activityState;
+                    updates.activityUpdatedAt = Date.now();
+                }
+                if (terminalMetadata.agentSessionId && terminalMetadata.agentSessionId !== worker.agentSessionId) {
+                    updates.agentSessionId = terminalMetadata.agentSessionId;
+                }
+                if (Object.keys(updates).length > 0) {
+                    const updatedWorker = this.workerRegistry.updateWorker(worker.agentId, updates);
+                    if (updatedWorker) {
+                        if (updatedWorker.taskSummary
+                            && (updatedWorker.sessionId === this.nodeConversation.lastWorkerSessionId
+                                || updatedWorker.agentId === this.nodeConversation.lastWorkerAgentId)) {
+                            this.nodeConversation.lastTaskSummary = updatedWorker.taskSummary;
+                        }
+                        this.maybeNarrateWorkerStateChange(previousWorker || worker, updatedWorker);
+                    }
+                }
+            }
+            this.maybeNarrateWorkerStateChange(previousWorker || worker, this.workerRegistry.getWorkerByAgentId(worker.agentId) || worker);
+            if (sawTerminalMetadata) {
+                this.broadcastWorkerList();
+            }
+        }
+        const remoteAttached = this.remoteAttachedSessions.has(sessionId);
+        const localAttached = this.localAttachedSessions.has(sessionId);
+        if (!remoteAttached && !localAttached) {
+            return;
+        }
+        console.log(`[AgentNode] Forwarding live output: ${sessionId}, ${output.content.length} chars`);
+        if (remoteAttached) {
+            this.wsClient.send({
+                type: "output",
+                sessionId,
+                data: output.content,
+            });
+        }
+        if (localAttached) {
+            this.localDirectServer?.handleNodeMessage({
+                type: "output",
+                sessionId,
+                data: output.content,
+            });
+        }
+    }
+    sendServerMessage(message) {
+        this.wsClient.send(message);
+        this.localDirectServer?.handleNodeMessage(message);
+    }
+    sendToSource(source, message) {
+        if (source === "relay") {
+            this.wsClient.send(message);
+            return;
+        }
+        this.localDirectServer?.handleNodeMessage(message);
+    }
+    async startLocalDirectServer() {
+        this.localDirectServer = new LocalDirectServer({
+            host: this.options.localControlHost || "127.0.0.1",
+            port: this.options.localControlPort || 0,
+            nodeId: this.options.nodeId,
+            password: this.options.password,
+        }, {
+            handleIncomingMessage: async (message) => {
+                await this.handleIncomingMessage(message, "local");
+            },
+            handleSubscriptionChange: async (sessionId, attachedBrowserCount) => {
+                this.updateSessionSubscription("local", sessionId, attachedBrowserCount);
+            },
+        });
+        this.localDirectInfo = await this.localDirectServer.start();
+        console.log(`[AgentNode] Local direct web: ${this.localDirectInfo.webUrl}?relay=${encodeURIComponent(this.localDirectInfo.wsUrl)}&node=${encodeURIComponent(this.options.nodeId)}&pwd=${encodeURIComponent(this.options.password)}&autoconnect=1`);
+        console.log(`[AgentNode] Local direct ws: ${this.localDirectInfo.wsUrl}`);
+    }
+    updateSessionSubscription(source, sessionId, attachedBrowserCount) {
+        const targetSet = source === "relay" ? this.remoteAttachedSessions : this.localAttachedSessions;
+        if (attachedBrowserCount > 0) {
+            targetSet.add(sessionId);
+            this.liveAttachedSessions.add(sessionId);
+            return;
+        }
+        targetSet.delete(sessionId);
+        if (!this.remoteAttachedSessions.has(sessionId) && !this.localAttachedSessions.has(sessionId)) {
+            this.liveAttachedSessions.delete(sessionId);
+        }
+    }
+    async onRelayConnected() {
+        const isReconnect = this.relayConnectedOnce;
+        this.relayConnectedOnce = true;
+        for (const sessionId of this.remoteAttachedSessions) {
+            if (!this.localAttachedSessions.has(sessionId)) {
+                this.liveAttachedSessions.delete(sessionId);
+            }
+        }
+        this.remoteAttachedSessions.clear();
+        if (!this.running && !isReconnect) {
+            return;
+        }
+        console.log(isReconnect ? "[AgentNode] Relay reconnected, resyncing runtime snapshot" : "[AgentNode] Relay connected");
+        this.broadcastWorkerList();
+    }
+    maybeNarrateWorkerStateChange(previous, next) {
+        void previous;
+        void next;
+        // Chat replies should come only from the primary agent. Runtime/workbench updates
+        // continue to flow through worker lists and control-plane events instead.
+        return;
+    }
+    recordConversationTurn(role, text, extra = {}) {
+        this.nodeConversation = recordConversationTurn(this.nodeConversation, role, text, extra);
+    }
+}
+// CLI 入口
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--relay":
+            case "-r":
+                options.relayUrl = args[++i];
+                break;
+            case "--node-id":
+            case "-n":
+                options.nodeId = args[++i];
+                break;
+            case "--password":
+            case "-p":
+                options.password = args[++i];
+                break;
+            case "--plugins":
+                options.pluginDir = args[++i];
+                break;
+            case "--primary-plugin":
+                options.primaryPluginName = args[++i];
+                break;
+            case "--local-control-port":
+                options.localControlPort = Number(args[++i]);
+                break;
+            case "--local-bind":
+                options.localControlHost = args[++i];
+                break;
+            case "--disable-local-direct":
+                options.enableLocalDirect = false;
+                break;
+            case "--no-reconnect":
+                options.autoReconnect = false;
+                break;
+            case "--help":
+            case "-h":
+                showHelp();
+                process.exit(0);
+        }
+    }
+    // 环境变量覆盖
+    if (process.env.MAGIC_SHELL_RELAY)
+        options.relayUrl = process.env.MAGIC_SHELL_RELAY;
+    if (process.env.MAGIC_SHELL_NODE_ID)
+        options.nodeId = process.env.MAGIC_SHELL_NODE_ID;
+    if (process.env.MAGIC_SHELL_PASSWORD)
+        options.password = process.env.MAGIC_SHELL_PASSWORD;
+    if (process.env.MAGIC_SHELL_PLUGINS_DIR)
+        options.pluginDir = process.env.MAGIC_SHELL_PLUGINS_DIR;
+    if (process.env.MAGIC_SHELL_PRIMARY_PLUGIN)
+        options.primaryPluginName = process.env.MAGIC_SHELL_PRIMARY_PLUGIN;
+    if (process.env.MAGIC_SHELL_LOCAL_CONTROL_HOST)
+        options.localControlHost = process.env.MAGIC_SHELL_LOCAL_CONTROL_HOST;
+    if (process.env.MAGIC_SHELL_LOCAL_CONTROL_PORT)
+        options.localControlPort = Number(process.env.MAGIC_SHELL_LOCAL_CONTROL_PORT);
+    if (process.env.MAGIC_SHELL_DISABLE_LOCAL_DIRECT === "1")
+        options.enableLocalDirect = false;
+    // 默认值
+    if (!options.relayUrl)
+        options.relayUrl = "ws://localhost:8080";
+    if (!options.nodeId)
+        options.nodeId = generateId(8);
+    if (!options.password)
+        options.password = generateId(12);
+    if (!options.pluginDir)
+        options.pluginDir = getDefaultPluginDir();
+    if (!options.primaryPluginName)
+        options.primaryPluginName = "pie";
+    if (!options.localControlHost)
+        options.localControlHost = "127.0.0.1";
+    return options;
+}
+function generateId(length = 8) {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+        result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+}
+function showHelp() {
+    console.log(`
+AgentNode - Magic Shell 本地 Agent 连接器
+
+Usage: node node.js [options]
+
+Options:
+  -r, --relay <url>       Relay Server URL (default: ws://localhost:8080)
+  -n, --node-id <id>      Node ID (auto-generated if not provided)
+  -p, --password <pwd>    Connection password (auto-generated if not provided)
+  --plugins <dir>         Plugin directory (default: ./plugins)
+  --primary-plugin <name> Primary agent plugin (default: pie)
+  --local-control-port    Local direct workbench port (default: random)
+  --local-bind <host>     Local direct bind host (default: 127.0.0.1)
+  --disable-local-direct  Disable the local direct workbench server
+  --no-reconnect          Disable auto-reconnect
+  -h, --help              Show this help
+
+Environment Variables:
+  MAGIC_SHELL_RELAY       Relay URL
+  MAGIC_SHELL_NODE_ID     Node ID
+  MAGIC_SHELL_PASSWORD    Password
+  MAGIC_SHELL_PLUGINS_DIR Plugin directory
+  MAGIC_SHELL_PRIMARY_PLUGIN Primary agent plugin
+  MAGIC_SHELL_LOCAL_CONTROL_HOST Local direct bind host
+  MAGIC_SHELL_LOCAL_CONTROL_PORT Local direct port
+  MAGIC_SHELL_DISABLE_LOCAL_DIRECT Set to 1 to disable the local direct server
+`);
+}
+// 主函数
+async function main() {
+    const options = parseArgs();
+    const node = new AgentNode(options);
+    // 优雅退出
+    process.on("SIGINT", async () => {
+        await node.stop();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await node.stop();
+        process.exit(0);
+    });
+    await node.start();
+}
+// 如果直接运行此文件
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((err) => {
+        console.error("[AgentNode] Fatal error:", err);
+        process.exit(1);
+    });
+}
+export { main };