@winmatrix/daemon 1.0.4 → 1.0.5

package/dist/core/AgentProcessManager.js

@@ -0,0 +1,701 @@
+/**
+ * WinMatrix Daemon - Agent Process Manager (v2)
+ *
+ * 管理外部 Agent 适配器实例生命周期�? * 收到 server �?agent.create / agent.stop 信令后，
+ * 实例化对应的 AgentAdapter 并创�?WinMatrixAgentClient 连接�? *
+ * 方案 B：adapter �?daemon 进程内直接运行，不再 spawn 子进程�? */
+import { WinMatrixAgentClient, } from './WinMatrixAgentClient.js';
+import { getGlobalRegistry, } from '@winmatrix/agent-sdk';
+import { METHODS, } from '@winmatrix/protocol';
+import { formatDaemonLocalTimestamp } from './DaemonFileLogger.js';
+/* ── Manager Class ── */
+export class AgentProcessManager {
+    agents = new Map();
+    pendingCreations = new Map();
+    registry;
+    taskAudit = [];
+    static TASK_AUDIT_MAX = 120;
+    onProfilesChanged = null;
+    constructor(registry) {
+        this.registry = registry ?? getGlobalRegistry();
+    }
+    /** Set callback invoked when agent profiles change (create/destroy/rescan) */
+    setOnProfilesChanged(fn) {
+        this.onProfilesChanged = fn;
+    }
+    recordTaskAudit(entry) {
+        this.taskAudit.push(entry);
+        if (this.taskAudit.length > AgentProcessManager.TASK_AUDIT_MAX) {
+            this.taskAudit.splice(0, this.taskAudit.length - AgentProcessManager.TASK_AUDIT_MAX);
+        }
+    }
+    appendRunEvent(run, event) {
+        const envelope = {
+            runKey: run.ref.runKey,
+            engineId: run.ref.engineId,
+            invocationFingerprint: run.ref.invocationFingerprint,
+            sequence: run.lastSequence + 1,
+            timestamp: formatDaemonLocalTimestamp(),
+            event,
+        };
+        run.lastSequence = envelope.sequence;
+        run.events.push(envelope);
+        if (run.events.length > 1_000)
+            run.events.splice(0, run.events.length - 1_000);
+        return envelope;
+    }
+    async handleAgentEngineRequest(managed, method, paramsValue) {
+        const params = paramsValue && typeof paramsValue === 'object'
+            ? paramsValue
+            : {};
+        const runKey = typeof params.runKey === 'string' ? params.runKey : undefined;
+        const run = runKey ? managed.runs.get(runKey) : undefined;
+        if (method === METHODS.TASK_EVENTS_SUBSCRIBE) {
+            if (!run)
+                throw new Error(`Run not found: ${runKey ?? ''}`);
+            const afterSequence = typeof params.afterSequence === 'number' ? params.afterSequence : 0;
+            return { events: run.events.filter((event) => event.sequence > afterSequence) };
+        }
+        if (method === METHODS.TASK_INSPECT) {
+            if (!run)
+                throw new Error(`Run not found: ${runKey ?? ''}`);
+            return {
+                ref: run.ref,
+                ...(run.sessionRef ? { sessionRef: run.sessionRef } : {}),
+                status: run.status,
+                executionDurability: 'connection_bound',
+                eventStreamMode: 'replay',
+                eventRetention: { maxEvents: 1_000 },
+                lastSequence: run.lastSequence,
+                pendingInteractions: [],
+                ...(run.result ? { result: run.result } : {}),
+                recoverable: false,
+                protocolVersion: '1',
+            };
+        }
+        if (method === METHODS.TASK_INTERACTION_RESPOND) {
+            const response = params.response && typeof params.response === 'object'
+                ? params.response
+                : {};
+            return {
+                status: 'rejected',
+                responseId: String(response.responseId ?? 'missing'),
+                interactionId: String(response.interactionId ?? 'missing'),
+                error: {
+                    code: 'unsupported_capability',
+                    message: 'External adapter does not support interactive responses',
+                },
+            };
+        }
+        if (method === METHODS.TASK_CANCEL_RUN) {
+            if (!run)
+                throw new Error(`Run not found: ${runKey ?? ''}`);
+            if (['completed', 'failed', 'cancelled', 'interrupted'].includes(run.status)) {
+                return { status: 'already_terminal' };
+            }
+            run.status = 'cancel_requested';
+            this.appendRunEvent(run, { type: 'status', text: 'cancel_requested' });
+            managed.abortController?.abort();
+            if (managed.adapter.cancel)
+                await managed.adapter.cancel(run.ref.runKey);
+            return { status: 'accepted' };
+        }
+        if (method === METHODS.TASK_ACTIVE_LIST) {
+            const limit = typeof params.limit === 'number' && params.limit > 0 ? params.limit : 50;
+            const engineId = typeof params.engineId === 'string' ? params.engineId : undefined;
+            const runs = [...managed.runs.values()]
+                .filter((candidate) => ['accepted', 'starting', 'running', 'waiting_interaction', 'cancel_requested'].includes(candidate.status)
+                && (!engineId || candidate.ref.engineId === engineId))
+                .slice(0, limit)
+                .map((candidate) => ({
+                ref: candidate.ref,
+                ...(candidate.sessionRef ? { sessionRef: candidate.sessionRef } : {}),
+                status: candidate.status,
+                startedAt: candidate.startedAt,
+                lastSequence: candidate.lastSequence,
+                pendingInteractionCount: 0,
+            }));
+            return { runs };
+        }
+        const engineId = managed.adapter.meta.agentType === 'claude-code'
+            || managed.adapter.meta.agentType === 'codex'
+            || managed.adapter.meta.agentType === 'hermes'
+            || managed.adapter.meta.agentType === 'openclaw'
+            ? managed.adapter.meta.agentType
+            : 'custom';
+        if (method === METHODS.AGENT_ENGINE_LIST) {
+            const health = await managed.adapter.healthCheck();
+            return {
+                engines: [{
+                        engineId,
+                        label: managed.adapter.meta.runtime,
+                        availability: health.available ? 'ready' : 'unavailable',
+                        ...(health.version ? { version: health.version } : {}),
+                    }],
+            };
+        }
+        if (method === METHODS.AGENT_ENGINE_MODELS)
+            return { models: [] };
+        if (method === METHODS.AGENT_ENGINE_OPTIONS) {
+            return { engineId, modes: [], configOptions: [], commands: [], checkedAt: formatDaemonLocalTimestamp() };
+        }
+        if (method === METHODS.AGENT_ENGINE_PROBE) {
+            const requestedEngineId = typeof params.engineId === 'string' ? params.engineId : engineId;
+            if (requestedEngineId !== engineId) {
+                return {
+                    engineId: requestedEngineId,
+                    instanceId: managed.agentId,
+                    hostKind: 'external_computer',
+                    checkedAt: formatDaemonLocalTimestamp(),
+                    status: 'unavailable',
+                    binaryStatus: 'missing',
+                    credentialStatus: 'unknown',
+                    issues: [{ code: 'engine_not_registered', message: `Registered engine is ${engineId}` }],
+                };
+            }
+            const health = await managed.adapter.healthCheck();
+            return {
+                engineId,
+                instanceId: managed.agentId,
+                hostKind: 'external_computer',
+                checkedAt: formatDaemonLocalTimestamp(),
+                status: health.available ? 'ready' : 'unavailable',
+                binaryStatus: health.available ? 'found' : 'missing',
+                credentialStatus: health.available ? 'ready' : 'unknown',
+                ...(health.version ? { version: health.version } : {}),
+                issues: health.error ? [{ code: 'adapter_health_failed', message: health.error }] : [],
+            };
+        }
+        throw new Error(`Unsupported Agent Engine method: ${method}`);
+    }
+    /**
+     * 遍历所�?managed agents，收集其 tools/skills/toolCategories 统一上报�?   * 返回深拷贝的 profiles，确保修改原 meta 不影响已收集的数据�?   */
+    async collectAgentProfiles() {
+        const profiles = [];
+        for (const [agentId, agent] of this.agents) {
+            profiles.push({
+                agentId,
+                agentType: agent.adapter.meta.agentType,
+                // 深拷�?tools 数组
+                tools: [...agent.adapter.meta.tools],
+                // 深拷�?skills 数组及其内部对象
+                skills: agent.adapter.meta.skills.map(s => ({ ...s })),
+                // 深拷�?toolCategories 及其内部数组
+                toolCategories: Object.fromEntries(Object.entries(agent.adapter.meta.toolCategories).map(([k, v]) => [k, [...v]])),
+            });
+        }
+        return profiles;
+    }
+    /**
+     * 重新扫描所�?agent �?skill 目录并触发立即心跳上报�?   * 用于诊断页面的「刷新技能」按钮手动触发�?   */
+    async rescanAndReportProfiles() {
+        for (const [, agent] of this.agents) {
+            if (agent.adapter.discoverSkills) {
+                try {
+                    const skills = await agent.adapter.discoverSkills({ workDir: agent.workDir });
+                    agent.adapter.meta.skills.splice(0, agent.adapter.meta.skills.length, ...skills);
+                }
+                catch {
+                    // best-effort
+                }
+            }
+        }
+        this.onProfilesChanged?.();
+    }
+    /**
+     * 创建 Agent 连接并启�?adapter�?   *
+     * 每个 agent 拥有独立�?WinMatrixAgentClient + WebSocket 连接�?   */
+    async createAgent(payload) {
+        const existing = this.agents.get(payload.agentId);
+        if (existing) {
+            return { ok: true, agent: existing };
+        }
+        const pending = this.pendingCreations.get(payload.agentId);
+        if (pending) {
+            return pending;
+        }
+        const creation = this.createAgentInternal(payload);
+        this.pendingCreations.set(payload.agentId, creation);
+        try {
+            return await creation;
+        }
+        finally {
+            if (this.pendingCreations.get(payload.agentId) === creation) {
+                this.pendingCreations.delete(payload.agentId);
+            }
+        }
+    }
+    async createAgentInternal(payload) {
+        if (!this.registry.has(payload.agentType)) {
+            return { ok: false, error: `Unknown agent type: ${payload.agentType}. Registered: ${this.registry.listTypes().join(', ')}` };
+        }
+        const adapter = this.registry.create(payload.agentType, payload.adapterConfig);
+        let managed;
+        const client = new WinMatrixAgentClient({
+            url: payload.serverUrl,
+            apiKey: payload.apiKey,
+            agentId: payload.agentId,
+            name: payload.name ?? payload.agentType,
+            agentType: payload.agentType,
+            capabilities: adapter.meta.capabilities,
+            autoReconnect: true,
+            taskAssignAdmission: (paramsValue) => {
+                const params = paramsValue && typeof paramsValue === 'object'
+                    ? paramsValue
+                    : {};
+                const runKey = typeof params.runKey === 'string' ? params.runKey : undefined;
+                const fingerprint = typeof params.invocationFingerprint === 'string'
+                    ? params.invocationFingerprint
+                    : undefined;
+                if (!runKey || !fingerprint)
+                    return { ok: true };
+                const existingRun = managed.runs.get(runKey);
+                if (existingRun) {
+                    return existingRun.ref.invocationFingerprint === fingerprint
+                        ? { ok: true, disposition: 'existing' }
+                        : { ok: false, error: `RUN_IDENTITY_MISMATCH: ${runKey}` };
+                }
+                if (managed.busy)
+                    return { ok: false, error: 'AGENT_BUSY' };
+                return { ok: true, disposition: 'accepted' };
+            },
+            agentEngineRequestHandler: (method, params) => this.handleAgentEngineRequest(managed, method, params),
+            sessionQueryHandler: async (method, params) => {
+                if (method === 'session.list') {
+                    return adapter.listSessions?.(params) ?? { sessions: [], total: 0 };
+                }
+                if (method === 'session.get') {
+                    const p = params;
+                    return (adapter.getSession?.(p.sessionId, p) ?? {
+                        session: { id: p.sessionId, summary: 'N/A', createdAt: '', lastActivityAt: '' },
+                        messageCount: 0,
+                        truncated: false,
+                        userPrompts: [],
+                        assistantText: '',
+                        lastAssistantText: '',
+                    });
+                }
+                if (method === 'session.search') {
+                    // task 6.10：会话搜索。daemon 端 ClaudeAdapter 支持时委派，否则返回空结果。
+                    const p = params;
+                    return (adapter.searchSessions?.(p) ?? { sessions: [] });
+                }
+                if (method === 'session.delete') {
+                    // task 6.10：幂等删除会话。requestId 支撑上层幂等去重（daemon 端按 sessionId 删除文件）。
+                    const p = params;
+                    return (adapter.deleteSession?.(p.sessionId, { requestId: p.requestId ?? p.sessionId }) ?? {
+                        status: 'rejected',
+                        error: 'deleteSession not supported by adapter',
+                    });
+                }
+                throw new Error(`Unsupported session method: ${method}`);
+            },
+        });
+        managed = {
+            agentId: payload.agentId,
+            adapter,
+            client,
+            abortController: null,
+            busy: false,
+            workDir: payload.workDir,
+            runs: new Map(),
+        };
+        // 断连时不再立即 abort CC 进程 —— 让其继续执行，
+        // 完成后等待 client 重连再发送结果。
+        // 仅在非 busy 时记录日志。
+        client.on('disconnect', (() => {
+            if (!managed.busy)
+                return;
+            console.warn(`[agent:${payload.agentId}] connection disconnected during task execution, ` +
+                `CC process will continue; result will be sent after reconnect`);
+        }));
+        // task.resume 中途递话（harden-external-computer-daemon P2/D5）：
+        // 运行中 run → adapter.steer（turn 边界注入 stdin，立即排队生效）；
+        // 无运行中 run / adapter 不支持 → 回 task.error（调用方可走 followup 新 run）
+        client.on('resume', ((input) => {
+            const resumeInput = input;
+            const text = typeof resumeInput.text === 'string' ? resumeInput.text.trim() : '';
+            if (!text) {
+                client.sendFrame({
+                    type: 'event',
+                    event: 'task.error',
+                    payload: { taskId: resumeInput.taskId, error: 'task.resume 缺少 text', code: 'RESUME_REJECTED' },
+                });
+                return;
+            }
+            const result = managed.adapter.steer?.(text) ?? { accepted: false, reason: 'unsupported' };
+            if (result.accepted) {
+                console.log(`[agent:${payload.agentId}] steer accepted taskId=${resumeInput.taskId} textLength=${text.length}`);
+                this.recordTaskAudit({
+                    ts: formatDaemonLocalTimestamp(),
+                    agentId: payload.agentId,
+                    taskId: resumeInput.taskId,
+                    event: 'task_start',
+                    detail: `steer textLength=${text.length}`,
+                });
+            }
+            else {
+                client.sendFrame({
+                    type: 'event',
+                    event: 'task.error',
+                    payload: {
+                        taskId: resumeInput.taskId,
+                        error: `steer 未受理: ${result.reason ?? 'no_active_run'}`,
+                        code: 'RESUME_REJECTED',
+                    },
+                });
+            }
+        }));
+        // Handle task.assign（design D11.1：支持统一信封 runKey/fingerprint 幂等 launch）
+        client.on('task', (async (taskInput) => {
+            const task = taskInput;
+            const runKey = task.runKey;
+            const fingerprint = task.invocationFingerprint;
+            if (managed.busy) {
+                // 幂等重投：同一 runKey 重复 assign 且 fingerprint 一致 → 不重复执行，按正常处理静默丢弃
+                // （task.assign ACK 已在 SDK 收到帧时回 ok，此处无需再发事件）。
+                if (runKey && runKey === managed.activeRunKey) {
+                    if (fingerprint && managed.activeFingerprint && fingerprint !== managed.activeFingerprint) {
+                        // 同 runKey 不同 fingerprint → 身份冲突
+                        this.recordTaskAudit({
+                            ts: formatDaemonLocalTimestamp(),
+                            agentId: payload.agentId,
+                            taskId: task.taskId,
+                            event: 'task_fail',
+                            detail: 'RUN_IDENTITY_MISMATCH',
+                        });
+                        client.sendFrame({
+                            type: 'event',
+                            event: 'task.error',
+                            payload: {
+                                taskId: task.taskId,
+                                error: `Run identity mismatch for runKey=${runKey}`,
+                                code: 'RUN_IDENTITY_MISMATCH',
+                            },
+                        });
+                    }
+                    // 同 runKey 同 fingerprint：重复 assign，静默幂等 ack（不重复执行）
+                    return;
+                }
+                // 不同 runKey 且 busy → 真正的并发拒绝
+                this.recordTaskAudit({
+                    ts: formatDaemonLocalTimestamp(),
+                    agentId: payload.agentId,
+                    taskId: task.taskId,
+                    event: 'task_fail',
+                    detail: 'AGENT_BUSY',
+                });
+                client.sendFrame({
+                    type: 'event',
+                    event: 'task.error',
+                    payload: { taskId: task.taskId, error: 'Agent busy', code: 'AGENT_BUSY' },
+                });
+                return;
+            }
+            managed.busy = true;
+            managed.activeRunKey = runKey;
+            managed.activeFingerprint = fingerprint;
+            const engineId = task.launchSpec?.engineId
+                ?? (adapter.meta.agentType === 'claude-code'
+                    || adapter.meta.agentType === 'codex'
+                    || adapter.meta.agentType === 'hermes'
+                    || adapter.meta.agentType === 'openclaw'
+                    ? adapter.meta.agentType
+                    : 'custom');
+            const run = runKey && fingerprint
+                ? {
+                    ref: {
+                        instance: { instanceId: payload.agentId, hostKind: 'external_computer' },
+                        executionSnapshot: {},
+                        runKey,
+                        engineId,
+                        invocationFingerprint: fingerprint,
+                    },
+                    status: 'running',
+                    startedAt: formatDaemonLocalTimestamp(),
+                    lastSequence: 0,
+                    events: [],
+                }
+                : undefined;
+            if (run) {
+                managed.runs.set(run.ref.runKey, run);
+                if (managed.runs.size > 100) {
+                    const oldestTerminal = [...managed.runs.entries()].find(([, candidate]) => ['completed', 'failed', 'cancelled', 'interrupted'].includes(candidate.status));
+                    if (oldestTerminal)
+                        managed.runs.delete(oldestTerminal[0]);
+                }
+                this.appendRunEvent(run, { type: 'status', text: 'running' });
+            }
+            console.log(`[agent:${payload.agentId}] task start taskId=${task.taskId} runKey=${runKey ?? '-'} inputLength=${task.input.length}`);
+            this.recordTaskAudit({
+                ts: formatDaemonLocalTimestamp(),
+                agentId: payload.agentId,
+                taskId: task.taskId,
+                event: 'task_start',
+                // 仅记录长度等非敏感元数据；runKey 非敏感，可记录
+                detail: `inputLength=${task.input.length}${runKey ? ` runKey=${runKey}` : ''}`,
+            });
+            const abortController = new AbortController();
+            managed.abortController = abortController;
+            /**
+             * 尝试通过 client 发送帧。如果当前 disconnected，等待重连后再发送。
+             * 超时后放弃（避免无限等待）。
+             */
+            const waitForReconnectAndSend = async (sendFn, label) => {
+                // 先尝试直接发送
+                try {
+                    if (client.getState() === 'registered') {
+                        sendFn();
+                        return;
+                    }
+                }
+                catch { /* ignore */ }
+                // 等待重连，最多 120 秒
+                const deadline = Date.now() + 120_000;
+                while (Date.now() < deadline) {
+                    await new Promise((r) => setTimeout(r, 2000));
+                    try {
+                        if (client.getState() === 'registered') {
+                            sendFn();
+                            console.log(`[agent:${payload.agentId}] ${label} sent after reconnect`);
+                            return;
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+                console.warn(`[agent:${payload.agentId}] ${label} dropped: reconnect timeout (120s)`);
+            };
+            try {
+                for await (const event of adapter.execute({
+                    taskId: task.taskId,
+                    input: task.input,
+                    mode: 'session',
+                    workDir: managed.workDir ?? payload.workDir ?? task.workDir,
+                    systemPrompt: task.systemPrompt,
+                    mcpToken: task.mcpToken,
+                    sessionId: task.sessionId,
+                    resumeSession: task.resumeSession,
+                    env: task.env ?? task.launchSpec?.nonSensitiveEnv,
+                    claude: task.claude,
+                    hermes: task.hermes,
+                    openclaw: task.openclaw,
+                }, abortController.signal)) {
+                    if (event.type === 'thinking') {
+                        if (run) {
+                            this.appendRunEvent(run, event.engineEvent ?? { type: 'thinking_delta', text: event.content });
+                        }
+                        // thinking delta 断连时可丢弃，不等待重连
+                        try {
+                            client.sendFrame({
+                                type: 'event',
+                                event: 'task.delta',
+                                payload: {
+                                    taskId: task.taskId,
+                                    content: event.content,
+                                    meta: { stream: 'thinking' },
+                                    engineEvent: event.engineEvent ?? { type: 'thinking_delta', text: event.content },
+                                },
+                            });
+                        }
+                        catch { /* best-effort */ }
+                        continue;
+                    }
+                    switch (event.type) {
+                        case 'delta':
+                            if (run) {
+                                this.appendRunEvent(run, event.engineEvent ?? { type: 'content_delta', text: event.content });
+                            }
+                            // delta 断连时可丢弃（server 端通过 result 兜底）
+                            try {
+                                client.streamDelta(task.taskId, event.content, undefined, event.engineEvent ?? { type: 'content_delta', text: event.content });
+                            }
+                            catch { /* best-effort */ }
+                            break;
+                        case 'tool_call': {
+                            if (run) {
+                                this.appendRunEvent(run, event.engineEvent ?? { type: 'tool_call', name: event.name });
+                            }
+                            try {
+                                await client.callTool(event.name, event.args, task.taskId);
+                            }
+                            catch (err) {
+                                console.error(`[agent:${payload.agentId}] tool call failed tool=${event.name} error=${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            break;
+                        }
+                        case 'result':
+                            if (run) {
+                                const result = {
+                                    success: true,
+                                    text: event.content,
+                                    ...(event.sessionId ? { sessionId: event.sessionId } : {}),
+                                    ...(event.usage ? {
+                                        usage: { inputTokens: event.usage.input, outputTokens: event.usage.output },
+                                    } : {}),
+                                };
+                                run.status = 'completed';
+                                run.result = result;
+                                if (event.sessionId) {
+                                    run.sessionRef = {
+                                        instance: run.ref.instance,
+                                        engineId: run.ref.engineId,
+                                        sessionId: event.sessionId,
+                                    };
+                                }
+                                this.appendRunEvent(run, { type: 'result', result });
+                            }
+                            // 关键帧：等待重连后发送，确保服务端收到最终结果
+                            await waitForReconnectAndSend(() => client.completeTask(task.taskId, event.content, event.sessionId, event.usage), `task complete taskId=${task.taskId}`);
+                            console.log(`[agent:${payload.agentId}] task complete taskId=${task.taskId} sessionId=${event.sessionId ?? '-'}`);
+                            this.recordTaskAudit({
+                                ts: formatDaemonLocalTimestamp(),
+                                agentId: payload.agentId,
+                                taskId: task.taskId,
+                                event: 'task_complete',
+                                detail: `sessionId=${event.sessionId ?? '-'}`,
+                            });
+                            return;
+                        case 'error':
+                            if (run) {
+                                const result = { success: false, error: event.message };
+                                run.status = 'failed';
+                                run.result = result;
+                                this.appendRunEvent(run, { type: 'error', error: event.message, ...(event.code ? { code: event.code } : {}) });
+                                this.appendRunEvent(run, { type: 'result', result });
+                            }
+                            await waitForReconnectAndSend(() => client.failTask(task.taskId, event.message, event.code), `task error taskId=${task.taskId}`);
+                            console.error(`[agent:${payload.agentId}] task error taskId=${task.taskId} error=${event.message}`);
+                            this.recordTaskAudit({
+                                ts: formatDaemonLocalTimestamp(),
+                                agentId: payload.agentId,
+                                taskId: task.taskId,
+                                event: 'task_error',
+                                detail: event.message,
+                            });
+                            return;
+                    }
+                }
+                if (run && !run.result) {
+                    const result = {
+                        success: false,
+                        error: 'Adapter stream ended without a terminal result',
+                    };
+                    run.status = 'interrupted';
+                    run.result = result;
+                    this.appendRunEvent(run, { type: 'result', result });
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (run && !run.result) {
+                    const cancelled = abortController.signal.aborted;
+                    const result = {
+                        success: false,
+                        error: cancelled ? 'cancelled' : msg,
+                    };
+                    run.status = cancelled ? 'cancelled' : 'failed';
+                    run.result = result;
+                    this.appendRunEvent(run, cancelled
+                        ? { type: 'status', text: 'cancelled' }
+                        : { type: 'error', error: msg });
+                    this.appendRunEvent(run, { type: 'result', result });
+                }
+                await waitForReconnectAndSend(() => client.failTask(task.taskId, msg), `task fail taskId=${task.taskId}`).catch(() => { });
+                console.error(`[agent:${payload.agentId}] task failed taskId=${task.taskId} error=${msg}`);
+                this.recordTaskAudit({
+                    ts: formatDaemonLocalTimestamp(),
+                    agentId: payload.agentId,
+                    taskId: task.taskId,
+                    event: 'task_fail',
+                    detail: msg,
+                });
+            }
+            finally {
+                managed.abortController = null;
+                managed.busy = false;
+                managed.activeRunKey = undefined;
+                managed.activeFingerprint = undefined;
+            }
+        }));
+        // Connect
+        try {
+            await client.connect();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            client.disconnect();
+            return { ok: false, error: `Agent ${payload.agentId} connection failed: ${msg}` };
+        }
+        this.agents.set(payload.agentId, managed);
+        console.log(`[daemon] Agent ${payload.agentId} connected (type: ${payload.agentType})`);
+        // Discover skills on creation and write to adapter meta
+        if (adapter.discoverSkills) {
+            try {
+                const skills = await adapter.discoverSkills({ workDir: payload.workDir });
+                adapter.meta.skills.splice(0, adapter.meta.skills.length, ...skills);
+            }
+            catch {
+                // best-effort
+            }
+        }
+        // Notify profile change
+        this.onProfilesChanged?.();
+        return { ok: true, agent: managed };
+    }
+    /**
+     * 停止 Agent �?取消正在执行的任务，断开连接�?   */
+    async stopAgent(payload) {
+        const agent = this.agents.get(payload.agentId);
+        if (!agent) {
+            return { ok: false, error: `Agent ${payload.agentId} is not running` };
+        }
+        // Cancel running task
+        if (agent.abortController) {
+            agent.abortController.abort();
+        }
+        // Disconnect
+        try {
+            await agent.client.disconnect();
+        }
+        catch {
+            // Best-effort
+        }
+        this.agents.delete(payload.agentId);
+        console.log(`[daemon] Agent ${payload.agentId} stopped`);
+        // Notify profile change
+        this.onProfilesChanged?.();
+        return { ok: true };
+    }
+    /** 停止所�?Agent（shutdown 时调用） */
+    async stopAllAgents() {
+        for (const [agentId, agent] of this.agents) {
+            try {
+                if (agent.abortController) {
+                    agent.abortController.abort();
+                }
+                await agent.client.disconnect();
+                console.log(`[daemon] Agent ${agentId} stopped during shutdown`);
+            }
+            catch {
+                // Best-effort
+            }
+        }
+        this.agents.clear();
+    }
+    /** 列出当前运行�?Agent */
+    listAgents() {
+        return [...this.agents.values()].map((a) => ({
+            agentId: a.agentId,
+            state: a.client.getState(),
+        }));
+    }
+    /** 最近一段时间接�?完成的任务（内存环，供本机诊断页�?*/
+    getRecentTaskEvents() {
+        return [...this.taskAudit];
+    }
+    /** 检�?Agent 是否在运�?*/
+    isRunning(agentId) {
+        return this.agents.has(agentId);
+    }
+}
+//# sourceMappingURL=AgentProcessManager.js.map