@winmatrix/daemon 0.2.4 → 0.2.5

package/dist/wrapper/AgentWrapper.js

@@ -1,56 +1,24 @@
 /**
- * @deprecated 方案 B 下不再使用（adapter 在 daemon 进程内直接运行，不再 spawn 子进程）。
- * 保留供未来 multiprocess 模式参考，所有维护性修改应在此注明原因。
+ * @deprecated Scheme B runs adapters in-process; this multiprocess wrapper remains for reference.
  *
- * Agent Wrapper - Daemon 子进程入口
- *
- * 由 Daemon 通过 agent.create 信令 spawn 启动。
- * 通过 stdin/stdout JSON 帧与 Daemon 通信，Daemon 负责通过 WS 多路复用转发给 Server。
- *
- * 协议（stdin/stdout 均为 JSON Lines）：
- *   stdin:  {"type":"fwd","data":<Server 发来的帧>}
- *   stdout: {"type":"fwd","agentId":"...","data":<发往 Server 的帧>}
- *   stdout: {"type":"event","event":"agent.ready","payload":{...}}
- *   stdout: {"type":"event","event":"agent.stopped","payload":{...}}
- *   stdout: {"type":"event","event":"agent.error","payload":{...}}
- *
- * 任务模型：按 agentType 分发到不同执行模式：
- *   claude-code → spawn claude --print --output-format stream-json ...
- *   hermes      → fetch() POST 到 HTTP endpoint
- *   default     → spawn(runtime, ['--print', '--output-format', 'json', input])
+ * Agent Wrapper — stdin/stdout JSON Lines IPC with Daemon; task execution delegated to WrapperProcessManager.
  */
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { unwrapOpenClawPayloads } from '@winmatrix/agent-sdk';
-import { parseClaudeLine, splitLines } from './ClaudeStreamParser.js';
-import { resolveClaudeRuntimeCommand } from './claudeCommand.js';
 import { scanWorkDir, detectRuntimeInfo } from '../core/WorkspaceScanner.js';
-/* ── State ── */
+import { WrapperProcessManager, } from './AgentProcessManager.js';
 let config = null;
-const runningTasks = new Map();
-/* ── Helpers ── */
+let processManager = null;
 function send(frame) {
     process.stdout.write(JSON.stringify(frame) + '\n');
 }
 function parseStdin(line) {
     try {
         const parsed = JSON.parse(line);
-        if (parsed && typeof parsed === 'object') {
-            // Handle tool_result frames from daemon (Tool Proxy Fallback)
-            if (parsed.type === 'tool_result') {
-                handleToolResult(parsed);
-                return null; // Not a server frame, don't forward
-            }
-            if (parsed.type === 'fwd') {
-                return parsed;
-            }
+        if (parsed && typeof parsed === 'object' && parsed.type === 'fwd') {
+            return parsed;
         }
     }
     catch {
-        // ignore malformed lines
+        /* ignore malformed lines */
     }
     return null;
 }
@@ -76,11 +44,7 @@ function sendTaskDelta(taskId, content, meta) {
     send({
         type: 'fwd',
         agentId: config.agentId,
-        data: {
-            type: 'event',
-            event: 'task.delta',
-            payload,
-        },
+        data: { type: 'event', event: 'task.delta', payload },
     });
 }
 function sendTaskComplete(taskId, result, sessionId, usage) {
@@ -94,579 +58,9 @@ function sendTaskComplete(taskId, result, sessionId, usage) {
     send({
         type: 'fwd',
         agentId: config.agentId,
-        data: {
-            type: 'event',
-            event: 'task.complete',
-            payload,
-        },
+        data: { type: 'event', event: 'task.complete', payload },
     });
 }
-function cleanupTask(taskId) {
-    const entry = runningTasks.get(taskId);
-    if (!entry)
-        return;
-    runningTasks.delete(taskId);
-}
-/* ── Task Routing ── */
-function routeTask(task) {
-    if (!config)
-        return;
-    const taskId = task.taskId;
-    if (runningTasks.has(taskId)) {
-        sendTaskError(taskId, 'Task already running');
-        return;
-    }
-    switch (config.agentType) {
-        case 'claude-code':
-            spawnClaudeCodeTask(task);
-            break;
-        case 'hermes':
-            spawnHermesTask(task);
-            break;
-        case 'openclaw':
-            spawnOpenClawTask(task);
-            break;
-        default:
-            spawnGenericTask(task);
-            break;
-    }
-}
-/* ── Claude Code Task ── */
-/**
- * 在 workDir 下生成 .claude/mcp.json 配置，让 Claude Code 能通过 MCP Bridge 调用 WinMatrix 工具。
- * 如果 .claude/mcp.json 已存在，使用 mcp.winmatrix.json 并通过 --mcp-config 指定。
- */
-function generateClaudeMcpConfig(mcpBridgeUrl, mcpApiKey, workDir) {
-    const mcpConfig = {
-        mcpServers: {
-            winmatrix: {
-                type: 'http',
-                url: mcpBridgeUrl,
-                ...(mcpApiKey ? { headers: { Authorization: `Bearer ${mcpApiKey}` } } : {}),
-            },
-        },
-    };
-    const configDir = workDir ? join(workDir, '.claude') : join(homedir(), '.claude');
-    const primaryPath = join(configDir, 'mcp.json');
-    const fallbackPath = join(configDir, 'mcp.winmatrix.json');
-    try {
-        if (!existsSync(configDir)) {
-            mkdirSync(configDir, { recursive: true });
-        }
-        if (existsSync(primaryPath)) {
-            writeFileSync(fallbackPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
-            return ['--mcp-config', fallbackPath];
-        }
-        writeFileSync(primaryPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
-        return null;
-    }
-    catch (err) {
-        console.warn(`MCP 配置写入失败: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-const CLAUDE_BASE_ARGS = [
-    '--print',
-    '--verbose',
-    '--input-format', 'stream-json',
-    '--output-format', 'stream-json',
-    '--include-partial-messages',
-];
-function spawnClaudeCodeTask(task) {
-    if (!config)
-        return;
-    const taskId = task.taskId;
-    const workDir = task.workDir ?? config.workDir;
-    const claude = task.claude ?? {};
-    // Validate workDir
-    if (workDir && !existsSync(workDir)) {
-        sendTaskError(taskId, `Work directory does not exist: ${workDir}`);
-        return;
-    }
-    // Assemble CLI args
-    const args = [...CLAUDE_BASE_ARGS];
-    // Permission mode (from task config, default 'auto')
-    const permissionMode = claude.permissionMode ?? 'bypassPermissions';
-    args.push('--permission-mode', permissionMode);
-    // workDir → --add-dir
-    if (workDir) {
-        args.push('--add-dir', workDir);
-    }
-    // Session management: oneshot skips --session-id entirely
-    const isOneshot = task.mode === 'oneshot';
-    let sessionId;
-    if (!isOneshot) {
-        if (claude.forkSession) {
-            sessionId = randomUUID();
-            args.push('--session-id', sessionId);
-        }
-        else if (claude.resumeSession && claude.sessionId) {
-            sessionId = claude.sessionId;
-            args.push('--resume', sessionId);
-        }
-        else if (claude.sessionId) {
-            sessionId = claude.sessionId;
-            args.push('--session-id', sessionId);
-        }
-        else {
-            sessionId = randomUUID();
-            args.push('--session-id', sessionId);
-        }
-    }
-    // Tool restriction
-    if (claude.tools && claude.tools.length > 0) {
-        args.push('--allowedTools', claude.tools.join(','));
-    }
-    if (claude.disallowedTools && claude.disallowedTools.length > 0) {
-        args.push('--disallowedTools', claude.disallowedTools.join(','));
-    }
-    // Budget
-    if (claude.maxBudgetUsd !== undefined) {
-        args.push('--max-budget-usd', String(claude.maxBudgetUsd));
-    }
-    // System prompt: task.systemPrompt 优先于 claude.systemPrompt
-    const effectiveSystemPrompt = task.systemPrompt ?? claude.systemPrompt;
-    if (effectiveSystemPrompt) {
-        args.push('--append-system-prompt', effectiveSystemPrompt);
-    }
-    // MCP Bridge 配置：在 workDir 下生成 .claude/mcp.json 或 mcp.winmatrix.json
-    if (config.mcpBridgeUrl) {
-        const effectiveMcpKey = task.mcpToken ?? config.mcpApiKey;
-        const mcpArgs = generateClaudeMcpConfig(config.mcpBridgeUrl, effectiveMcpKey, workDir);
-        if (mcpArgs) {
-            args.push(...mcpArgs);
-        }
-    }
-    // Build env
-    const env = {
-        ...process.env,
-        WINMATRIX_AGENT_ID: config.agentId,
-        WINMATRIX_API_KEY: config.apiKey,
-        WINMATRIX_AGENT_NAME: config.name,
-        WINMATRIX_AGENT_TYPE: config.agentType,
-        WINMATRIX_TASK_ID: taskId,
-        ...task.env,
-    };
-    let proc;
-    try {
-        const spawnSpec = resolveClaudeRuntimeCommand(config.runtime);
-        proc = spawn(spawnSpec.command, args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env,
-            cwd: workDir ?? process.cwd(),
-            shell: spawnSpec.shell,
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        sendTaskError(taskId, `Failed to spawn Claude Code: ${message}`);
-        return;
-    }
-    const entry = {
-        taskId,
-        process: proc,
-        abortController: null,
-        startedAt: Date.now(),
-        stdoutChunks: [],
-        completed: false,
-    };
-    runningTasks.set(taskId, entry);
-    proc.on('error', (err) => {
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        sendTaskError(taskId, err.message);
-        cleanupTask(taskId);
-    });
-    // Send user message via stdin (stream-json protocol)
-    const userMessage = JSON.stringify({
-        type: 'user',
-        message: { role: 'user', content: task.input },
-    }) + '\n';
-    proc.stdin?.write(userMessage);
-    proc.stdin?.end();
-    // Track extracted fields from result event for task.complete
-    let extractedSessionId;
-    let extractedResultText;
-    let extractedUsage;
-    // Parse stdout stream-json events
-    let stdoutBuffer = '';
-    proc.stdout?.on('data', (data) => {
-        const chunk = data.toString('utf-8');
-        const { lines, remainder } = splitLines(stdoutBuffer, chunk);
-        stdoutBuffer = remainder;
-        for (const line of lines) {
-            entry.stdoutChunks.push(line + '\n');
-            const action = parseClaudeLine(line);
-            switch (action.type) {
-                case 'delta':
-                    sendTaskDelta(taskId, action.text);
-                    break;
-                case 'thinking':
-                    sendTaskDelta(taskId, action.text, { stream: 'thinking' });
-                    break;
-                case 'tool_use':
-                    sendTaskDelta(taskId, `[调用工具: ${action.toolName}]`, { toolUse: { name: action.toolName, input: action.toolInput } });
-                    break;
-                case 'result':
-                    if (action.sessionId) {
-                        extractedSessionId = action.sessionId;
-                    }
-                    if (action.result) {
-                        extractedResultText = action.result;
-                    }
-                    if (action.usage) {
-                        extractedUsage = action.usage;
-                    }
-                    break;
-                case 'error':
-                    entry.completed = true;
-                    sendTaskError(taskId, action.message);
-                    return;
-                case 'skip':
-                    break;
-            }
-        }
-    });
-    // Forward stderr as task.delta with meta marker to distinguish from stdout content
-    proc.stderr?.on('data', (data) => {
-        const text = data.toString('utf-8').trimEnd();
-        if (!text)
-            return;
-        sendTaskDelta(taskId, text, { source: 'stderr' });
-    });
-    proc.on('exit', (code, signal) => {
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        if (extractedSessionId || code === 0) {
-            // Use result text extracted from stream-json result event
-            sendTaskComplete(taskId, { result: extractedResultText ?? null, exitCode: code ?? 0 }, isOneshot ? undefined : extractedSessionId, extractedUsage);
-        }
-        else {
-            sendTaskError(taskId, signal
-                ? `Claude Code killed by signal ${signal}`
-                : `Claude Code exited with code ${code ?? 'null'}`);
-        }
-        cleanupTask(taskId);
-    });
-}
-/* ── HTTP Task (shared by hermes / openclaw) ── */
-const DEFAULT_HTTP_TIMEOUT_MS = 180000;
-/**
- * Shared HTTP POST task execution.
- * Hermes and OpenClaw both POST to an endpoint; OpenClaw additionally unwraps the payload.
- *
- * Tool Proxy Fallback: when the HTTP response contains "unsupported mcp biz type" or
- * errcode 846610, the Wrapper sends tool_call IPC frames to the daemon for each
- * fallback tool call, aggregates results, and completes the task with mode: 'fallback'.
- */
-function spawnHttpTask(task, options) {
-    if (!config)
-        return;
-    const taskId = task.taskId;
-    // Task-level endpoint overrides config-level; fallback to deprecated hermesEndpoint
-    const endpoint = task.endpoint ?? config.endpoint ?? config.hermesEndpoint;
-    if (!endpoint) {
-        sendTaskError(taskId, 'HTTP endpoint not configured');
-        return;
-    }
-    const timeoutMs = task.hermes?.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
-    const abortController = new AbortController();
-    const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
-    const entry = {
-        taskId,
-        process: null,
-        abortController,
-        startedAt: Date.now(),
-        stdoutChunks: [],
-        completed: false,
-    };
-    runningTasks.set(taskId, entry);
-    // Build request headers
-    const headers = { 'Content-Type': 'application/json' };
-    const token = task.endpointToken ?? config.endpointToken;
-    if (token) {
-        headers['Authorization'] = `Bearer ${token}`;
-    }
-    // systemPrompt 拼接到 input 前方（Hermes/OpenClaw Gateway 不支持独立 system prompt 参数）
-    const effectiveInput = task.systemPrompt
-        ? `${task.systemPrompt}\n\n---\n\n${task.input}`
-        : task.input;
-    entry.completionPromise = fetch(endpoint, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-            taskId: task.taskId,
-            input: effectiveInput,
-            context: task.context,
-            ...(task.systemPrompt ? { systemPrompt: task.systemPrompt } : {}),
-            ...(config.mcpBridgeUrl ? { mcpBridgeUrl: config.mcpBridgeUrl } : {}),
-            ...((task.mcpToken ?? config.mcpApiKey) ? { mcpToken: (task.mcpToken ?? config.mcpApiKey) } : {}),
-        }),
-        signal: abortController.signal,
-    })
-        .then(async (res) => {
-        clearTimeout(timeoutId);
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        if (!res.ok) {
-            sendTaskError(taskId, `HTTP ${res.status}: ${res.statusText}`);
-            cleanupTask(taskId);
-            return;
-        }
-        const bodyText = await res.text();
-        let parsed = bodyText;
-        try {
-            parsed = JSON.parse(bodyText);
-        }
-        catch {
-            // Non-JSON response, keep raw text
-        }
-        // Apply unwrap if configured (openclaw) — unwrap expects raw string, internally JSON.parses
-        if (options.unwrap && typeof parsed === 'object' && parsed !== null) {
-            try {
-                parsed = options.unwrap(bodyText);
-            }
-            catch {
-                // unwrap failed, keep original
-            }
-        }
-        // Tool Proxy Fallback detection
-        const responseStr = typeof parsed === 'string' ? parsed : JSON.stringify(parsed);
-        if (/unsupported mcp biz type|errcode.*846610/i.test(responseStr)) {
-            const fallbackCalls = extractFallbackToolCalls(parsed);
-            if (fallbackCalls.length > 0) {
-                await executeFallbackToolCalls(taskId, fallbackCalls);
-                cleanupTask(taskId);
-                return;
-            }
-        }
-        sendTaskComplete(taskId, parsed);
-        cleanupTask(taskId);
-    })
-        .catch((err) => {
-        clearTimeout(timeoutId);
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        const message = err instanceof Error ? err.message : String(err);
-        if (err.name === 'AbortError') {
-            sendTaskError(taskId, `HTTP request timed out after ${timeoutMs}ms`);
-        }
-        else {
-            sendTaskError(taskId, `HTTP request failed: ${message}`);
-        }
-        cleanupTask(taskId);
-    });
-}
-function spawnHermesTask(task) {
-    spawnHttpTask(task, {});
-}
-function spawnOpenClawTask(task) {
-    spawnHttpTask(task, { unwrap: unwrapOpenClawPayloads });
-}
-function extractFallbackToolCalls(parsed) {
-    const calls = [];
-    // Try to extract from common response shapes
-    let data = parsed;
-    if (typeof data === 'string') {
-        try {
-            data = JSON.parse(data);
-        }
-        catch {
-            return calls;
-        }
-    }
-    if (!data || typeof data !== 'object')
-        return calls;
-    // Shape: { tool_calls: [{ name, arguments }, ...] }
-    const rawCalls = data.tool_calls ?? data.toolCalls ?? data.calls;
-    if (Array.isArray(rawCalls)) {
-        for (const c of rawCalls) {
-            if (typeof c !== 'object' || c === null)
-                continue;
-            const name = c.name ?? c.tool_name ?? c.function;
-            if (typeof name !== 'string')
-                continue;
-            let args = {};
-            const rawArgs = c.arguments ?? c.args ?? c.parameters;
-            if (typeof rawArgs === 'string') {
-                try {
-                    args = JSON.parse(rawArgs);
-                }
-                catch {
-                    args = { raw: rawArgs };
-                }
-            }
-            else if (typeof rawArgs === 'object' && rawArgs !== null) {
-                args = rawArgs;
-            }
-            calls.push({ toolName: name, args });
-        }
-    }
-    // Shape: { tool_query: "..." } → single tool call
-    if (calls.length === 0 && typeof data.tool_query === 'string') {
-        calls.push({ toolName: 'tool_query', args: { query: data.tool_query } });
-    }
-    return calls;
-}
-async function executeFallbackToolCalls(taskId, calls) {
-    const results = [];
-    for (const call of calls) {
-        const callId = randomUUID();
-        // Send tool_call IPC to daemon
-        process.stdout.write(JSON.stringify({
-            type: 'tool_call',
-            callId,
-            taskId,
-            toolName: call.toolName,
-            args: call.args,
-        }) + '\n');
-        // Wait for tool_result from daemon via stdin
-        try {
-            const result = await waitForToolResult(callId, 30000);
-            results.push({ toolName: call.toolName, ok: true, result });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            results.push({ toolName: call.toolName, ok: false, error: message });
-        }
-    }
-    sendTaskComplete(taskId, { mode: 'fallback', calls: results });
-}
-/** Pending tool_result resolvers keyed by callId */
-const toolResultPending = new Map();
-function waitForToolResult(callId, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            toolResultPending.delete(callId);
-            reject(new Error('Tool call timed out'));
-        }, timeoutMs);
-        toolResultPending.set(callId, { resolve, reject, timer });
-    });
-}
-/** Called from stdin handler when a tool_result frame arrives from daemon */
-function handleToolResult(frame) {
-    const pending = toolResultPending.get(frame.callId);
-    if (!pending)
-        return;
-    clearTimeout(pending.timer);
-    toolResultPending.delete(frame.callId);
-    if (frame.ok) {
-        pending.resolve(frame.result);
-    }
-    else {
-        pending.reject(new Error(frame.error ?? 'Tool call failed'));
-    }
-}
-/* ── Generic Task (fallback) ── */
-function spawnGenericTask(task) {
-    if (!config)
-        return;
-    const taskId = task.taskId;
-    const workDir = task.workDir ?? config.workDir;
-    const args = ['--print', '--output-format', 'json', task.input];
-    let proc;
-    try {
-        proc = spawn(config.runtime, args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                WINMATRIX_AGENT_ID: config.agentId,
-                WINMATRIX_API_KEY: config.apiKey,
-                WINMATRIX_AGENT_NAME: config.name,
-                WINMATRIX_AGENT_TYPE: config.agentType,
-                WINMATRIX_TASK_ID: taskId,
-                ...task.env,
-            },
-            cwd: workDir ?? process.cwd(),
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        sendTaskError(taskId, `Failed to spawn runtime: ${message}`);
-        return;
-    }
-    const entry = {
-        taskId,
-        process: proc,
-        abortController: null,
-        startedAt: Date.now(),
-        stdoutChunks: [],
-        completed: false,
-    };
-    runningTasks.set(taskId, entry);
-    proc.stdout?.on('data', (data) => {
-        const text = data.toString('utf-8');
-        entry.stdoutChunks.push(text);
-        const trimmed = text.trimEnd();
-        if (!trimmed)
-            return;
-        sendTaskDelta(taskId, trimmed);
-    });
-    proc.stderr?.on('data', (data) => {
-        const text = data.toString('utf-8').trimEnd();
-        if (!text)
-            return;
-        sendTaskDelta(taskId, text, { source: 'stderr' });
-    });
-    proc.on('exit', (code, signal) => {
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        if (code === 0) {
-            const rawOutput = entry.stdoutChunks.join('');
-            let parsedResult = rawOutput;
-            try {
-                parsedResult = JSON.parse(rawOutput);
-            }
-            catch {
-                // Non-JSON output, keep raw
-            }
-            sendTaskComplete(taskId, parsedResult);
-        }
-        else {
-            sendTaskError(taskId, signal
-                ? `Process killed by signal ${signal}`
-                : `Process exited with code ${code ?? 'null'}`);
-        }
-        cleanupTask(taskId);
-    });
-    proc.on('error', (err) => {
-        if (entry.completed)
-            return;
-        entry.completed = true;
-        sendTaskError(taskId, err.message);
-        cleanupTask(taskId);
-    });
-}
-/* ── Task Cancellation ── */
-function cancelTask(taskId) {
-    const entry = runningTasks.get(taskId);
-    if (!entry)
-        return;
-    if (entry.abortController) {
-        entry.abortController.abort();
-    }
-    if (entry.process) {
-        try {
-            entry.process.kill('SIGTERM');
-            setTimeout(() => {
-                try {
-                    entry.process?.kill('SIGKILL');
-                }
-                catch { /* already dead */ }
-            }, 10000);
-        }
-        catch {
-            // process already exited
-        }
-    }
-    cleanupTask(taskId);
-}
-/* ── Register Flow ── */
 function sendRegister() {
     if (!config)
         return;
@@ -691,13 +85,11 @@ function sendRegister() {
         },
     });
 }
-/* ── Stdin Event Handling ── */
 async function sendWorkspaceReport() {
     if (!config?.workDir)
         return;
     try {
         const workdir = await scanWorkDir(config.workDir);
-        // Detect key runtime versions
         const runtimes = {};
         const runtimeBinaries = config.runtime ? [config.runtime] : [];
         for (const bin of runtimeBinaries) {
@@ -711,30 +103,24 @@ async function sendWorkspaceReport() {
         send({
             type: 'fwd',
             agentId: config.agentId,
-            data: {
-                type: 'event',
-                event: 'workspace.report',
-                payload,
-            },
+            data: { type: 'event', event: 'workspace.report', payload },
         });
     }
     catch {
-        // workspace scan failed silently - workDir may be inaccessible
+        /* workspace scan failed silently */
     }
 }
 function handleServerFrame(data) {
-    if (!config)
+    if (!config || !processManager)
         return;
-    // Handle register response
     if (data.type === 'res' && data.ok === true) {
         send({
             type: 'event',
             event: 'agent.ready',
             payload: { agentId: config.agentId, pid: process.pid },
         });
-        // Fire-and-forget workspace scan after agent is ready
         if (config.workDir) {
-            sendWorkspaceReport();
+            void sendWorkspaceReport();
         }
         return;
     }
@@ -750,29 +136,24 @@ function handleServerFrame(data) {
         process.exit(1);
         return;
     }
-    // Handle task.assign event
     if (data.type === 'event' && data.event === 'task.assign') {
         const payload = (data.payload ?? {});
         if (payload.taskId && payload.input) {
-            routeTask(payload);
+            processManager.routeTask(payload);
         }
         return;
     }
-    // Handle task.cancel event
     if (data.type === 'event' && data.event === 'task.cancel') {
         const payload = data.payload;
         if (payload?.taskId) {
-            cancelTask(payload.taskId);
+            processManager.cancelTask(payload.taskId);
         }
         return;
     }
-    // Handle reconnect event (Daemon reconnected, re-register)
     if (data.type === 'event' && data.event === 'reconnect') {
         sendRegister();
-        return;
     }
 }
-/* ── Main ── */
 function main() {
     const args = process.argv.slice(2);
     const parsed = {};
@@ -800,16 +181,17 @@ function main() {
         send({
             type: 'event',
             event: 'agent.error',
-            payload: {
-                error: 'Missing required --agent-id or WINMATRIX_API_KEY env',
-            },
+            payload: { error: 'Missing required --agent-id or WINMATRIX_API_KEY env' },
         });
         process.exit(1);
         return;
     }
-    // Step 1: Send register frame via stdout (Daemon forwards to Server)
+    processManager = new WrapperProcessManager(config, {
+        onDelta: sendTaskDelta,
+        onComplete: sendTaskComplete,
+        onError: sendTaskError,
+    });
     sendRegister();
-    // Step 2: Wait for register response and task events via stdin
     process.stdin.setEncoding('utf-8');
     let buffer = '';
     process.stdin.on('data', (chunk) => {
@@ -827,53 +209,21 @@ function main() {
         }
     });
     process.stdin.on('end', () => {
-        shutdown();
+        void shutdown();
     });
     process.stdin.resume();
-    // Handle termination signals
-    function shutdown() {
-        // First pass: abort fetch tasks and SIGTERM child processes
-        for (const [, entry] of runningTasks) {
-            if (entry.abortController) {
-                entry.abortController.abort();
-            }
-            if (entry.process) {
-                try {
-                    entry.process.kill('SIGTERM');
-                }
-                catch { /* already dead */ }
-            }
-        }
-        // Wait for in-flight fetch tasks to settle (with 5s timeout),
-        // then SIGKILL any remaining child processes.
-        const fetchPromises = [...runningTasks.values()]
-            .filter((e) => e.completionPromise)
-            .map((e) => e.completionPromise);
-        const finalize = () => {
-            for (const [, entry] of runningTasks) {
-                if (entry.process) {
-                    try {
-                        entry.process.kill('SIGKILL');
-                    }
-                    catch { /* already dead */ }
-                }
-            }
-            runningTasks.clear();
-            process.exit(0);
-        };
-        if (fetchPromises.length > 0) {
-            Promise.race([
-                Promise.allSettled(fetchPromises),
-                new Promise((resolve) => setTimeout(resolve, 5000)),
-            ]).finally(finalize);
-        }
-        else {
-            // No fetch tasks: 10s grace for child process SIGTERM → SIGKILL
-            setTimeout(finalize, 10000);
+    async function shutdown() {
+        if (processManager) {
+            await processManager.shutdown();
         }
+        process.exit(0);
     }
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', () => {
+        void shutdown();
+    });
+    process.on('SIGINT', () => {
+        void shutdown();
+    });
 }
 main();
 //# sourceMappingURL=AgentWrapper.js.map