mixdog 0.9.87 → 0.9.89

package/src/standalone/agent-shard/shard-child.mjs

@@ -1,300 +0,0 @@
-// Agent shard child (P1 skeleton — see docs/agent-shard-design.md).
-//
-// Forked by shard-pool.mjs. Boots the session runtime HEADLESS in this
-// process (module singletons initialize from MIXDOG_DATA_DIR config on disk,
-// same recipe as the channels worker child) and executes agent WORKER
-// sessions on IPC request, so their provider wire encoding and tool
-// post-processing CPU never touches the lead's event loop.
-//
-// IPC protocol (channel-worker style):
-//   parent→child: { type: 'ping'|'spawn'|'cancel', callId, payload }
-//   child→parent: { type: 'ready' }
-//               | { type: 'progress', callId, event, payload }
-//               | { type: 'result', callId, result|error }
-//
-// P2 parity in this file: `spawned` progress (lead mirrors tag/row/statusline
-// bookkeeping), the SAME idle-progress watchdog the in-process path runs
-// (registry lives here because the session state lives here), and the
-// watchdog partial-handoff salvage. MCP proxying, cooldown broadcast, and
-// tag-reuse routing remain open (design doc).
-import process from 'node:process';
-import { ensureProcessListenerHeadroom } from '../../runtime/shared/process-listener-headroom.mjs';
-
-// The session runtime registers several process exit/cleanup hooks; the
-// default 10-listener cap emits MaxListenersExceededWarning noise on stderr
-// (observed in the first P2 live run).
-ensureProcessListenerHeadroom(64);
-
-function send(msg) {
-    try { process.send?.(msg); } catch { /* parent gone — exit hook handles */ }
-}
-
-let _bootPromise = null;
-function boot() {
-    _bootPromise ??= (async () => {
-        const [cfgMod, reg, mgr, sessionBuilder, presetMod, providerInitMod, ownerMod, watchdogMod, watchdogRegistryMod, admissionMod, mcpClientMod, internalToolsMod] = await Promise.all([
-            import('../../runtime/agent/orchestrator/config.mjs'),
-            import('../../runtime/agent/orchestrator/providers/registry.mjs'),
-            import('../../runtime/agent/orchestrator/session/manager.mjs'),
-            import('../../runtime/agent/orchestrator/agent-runtime/session-builder.mjs'),
-            import('../agent-tool/spawn-preset.mjs'),
-            import('../agent-tool/provider-init.mjs'),
-            import('../../runtime/agent/orchestrator/agent-owner.mjs'),
-            import('../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs'),
-            import('../agent-watchdog-registry.mjs'),
-            import('../../runtime/agent/orchestrator/providers/admission-scheduler.mjs'),
-            import('../../runtime/agent/orchestrator/mcp/client.mjs'),
-            import('../../runtime/agent/orchestrator/internal-tools.mjs'),
-        ]);
-        const { ensureProvider } = providerInitMod.createProviderInit(reg, 120_000);
-        // Same idle-progress watchdog the in-process spawn path uses — it must
-        // run HERE because only this process can snapshot/abort its sessions.
-        const watchdogs = watchdogRegistryMod.createProgressWatchdogRegistry({ mgr });
-        // 429 fan-out: report locally-recorded cooldowns/resets upward; the
-        // lead applies them to its own scheduler and rebroadcasts to sibling
-        // shards so one account's quota window parks every process.
-        admissionMod.providerAdmissionScheduler.onCooldownEvent?.((event) => {
-            send({ type: 'rate-limit', payload: event });
-        });
-        return { cfgMod, reg, mgr, sessionBuilder, presetMod, ensureProvider, AGENT_OWNER: ownerMod.AGENT_OWNER, watchdogMod, watchdogs, admissionMod, mcpClientMod, internalToolsMod };
-    })();
-    return _bootPromise;
-}
-
-// ── Lead-tool proxy (P2 MCP proxy, generalized) ───────────────────────────
-// This process has no MCP connections and no internal-tool executor (both
-// are lead singletons). The spawn payload carries the lead's tool
-// DEFINITIONS; installing them here makes the session tool schema
-// byte-identical to an in-process worker, and every call round-trips to the
-// lead as a `lead-tool` IPC request.
-const LEAD_TOOL_TIMEOUT_MS = 15 * 60 * 1000;
-const _leadCalls = new Map();
-let _leadCallSeq = 0;
-
-function _leadToolCall(kind, name, args, callerCtx = null) {
-    return new Promise((resolve, reject) => {
-        const callId = `lt${++_leadCallSeq}`;
-        const timer = setTimeout(() => {
-            if (_leadCalls.delete(callId)) {
-                reject(new Error(`lead tool proxy timed out after ${LEAD_TOOL_TIMEOUT_MS}ms (${name})`));
-            }
-        }, LEAD_TOOL_TIMEOUT_MS);
-        timer.unref?.();
-        _leadCalls.set(callId, { resolve, reject, timer });
-        try {
-            send({ type: 'lead-tool', callId, payload: { kind, name, args, callerCtx } });
-        } catch (error) {
-            clearTimeout(timer);
-            _leadCalls.delete(callId);
-            reject(error);
-        }
-    });
-}
-
-function _installLeadToolProxy(rt, leadTools) {
-    const mcpTools = Array.isArray(leadTools?.mcp) ? leadTools.mcp : [];
-    const internalTools = Array.isArray(leadTools?.internal) ? leadTools.internal : [];
-    rt.mcpClientMod.setMcpToolProxy?.({
-        tools: mcpTools,
-        call: (name, args) => _leadToolCall('mcp', name, args),
-    });
-    if (internalTools.length > 0) {
-        rt.internalToolsMod.setInternalToolsProvider({
-            // Forward only the serializable caller context; signal/notifyFn are
-            // process-local (the tool-level timeout above bounds a hung call).
-            executor: (name, args, ctx = {}) => _leadToolCall('internal', name, args, {
-                callerSessionId: ctx.callerSessionId || null,
-                callerCwd: ctx.callerCwd || null,
-                clientHostPid: ctx.clientHostPid || null,
-                routingSessionId: ctx.routingSessionId || null,
-                shardWorker: true,
-            }),
-            tools: internalTools,
-        });
-    }
-}
-
-// sessionId → AbortController-ish handle for cancel (P1: close the session).
-const _liveSessions = new Set();
-
-const ops = {
-    async ping() {
-        return { pong: true, pid: process.pid };
-    },
-    async spawn(payload, ctx = {}) {
-        const rt = await boot();
-        const { cfgMod, mgr, sessionBuilder, presetMod, ensureProvider, AGENT_OWNER, watchdogMod, watchdogs } = rt;
-        const args = payload?.args || {};
-        const agent = String(args.agent || '').trim();
-        if (!agent) throw new Error('agent shard spawn: agent is required');
-        // Refresh the proxy surface BEFORE the session builds its tool list —
-        // MCP servers reconnect/toggle at runtime on the lead.
-        _installLeadToolProxy(rt, payload?.leadTools);
-        const config = cfgMod.loadConfig();
-        const { presetName, preset } = presetMod.resolveAgentSpawnPreset(config, args);
-        await ensureProvider(config, preset.provider);
-        const runtimeSpec = cfgMod.resolveRuntimeSpec(preset, { lane: 'agent', agentId: payload?.tag || agent });
-        const { session, effectiveCwd } = sessionBuilder.prepareAgentSession({
-            agent,
-            presetName,
-            preset,
-            runtimeSpec,
-            owner: AGENT_OWNER,
-            cwd: payload?.cwd || process.cwd(),
-            sourceType: 'cli',
-            sourceName: agent,
-            parentSessionId: payload?.parentSessionId || null,
-            ownerSessionId: payload?.ownerSessionId || null,
-            agentTag: payload?.tag || undefined,
-            maxLoopIterations: Number(payload?.maxLoopIterations) > 0 ? Number(payload.maxLoopIterations) : undefined,
-        });
-        _liveSessions.add(session.id);
-        if (payload?.tag) _sessionIdByTag.set(String(payload.tag), session.id);
-        // Session is bound — let the lead mirror its in-process spawn
-        // bookkeeping (tag map, worker-index row, statusline route,
-        // SubagentStart) while the loop runs here.
-        ctx.progress?.('spawned', {
-            sessionId: session.id,
-            tag: payload?.tag || null,
-            agent,
-            presetName,
-            provider: preset.provider,
-            model: preset.model,
-            effort: preset.effort || null,
-            fast: preset.fast === true,
-            cwd: effectiveCwd || payload?.cwd || process.cwd(),
-        });
-        const watchdog = watchdogs.start(session.id, watchdogMod.resolveAgentWatchdogPolicy(agent), agent);
-        const handoffMsgStart = watchdogMod.resolveHandoffMessageStartIndex(mgr.getSession(session.id));
-        try {
-            const result = await mgr.askSession(
-                session.id,
-                String(payload?.prompt || ''),
-                args.context || null,
-                null,
-                effectiveCwd || payload?.cwd || process.cwd(),
-                null,
-                {},
-            );
-            return {
-                sessionId: session.id,
-                tag: payload?.tag || null,
-                agent,
-                presetName,
-                provider: preset.provider,
-                model: preset.model,
-                effort: preset.effort || null,
-                fast: preset.fast === true,
-                content: result?.content || '',
-                terminationReason: result?.terminationReason || null,
-            };
-        } catch (error) {
-            // Watchdog-stall parity with the in-process path: salvage a
-            // partial handoff from the aborted session instead of surfacing a
-            // bare failure; the lead completes the task with stallAbort=true.
-            const partial = watchdogMod.watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
-            if (partial) {
-                return {
-                    sessionId: session.id,
-                    tag: payload?.tag || null,
-                    agent,
-                    presetName,
-                    provider: preset.provider,
-                    model: preset.model,
-                    effort: preset.effort || null,
-                    fast: preset.fast === true,
-                    content: partial,
-                    stallAbort: true,
-                    terminationReason: null,
-                };
-            }
-            throw error;
-        } finally {
-            watchdog?.stop?.();
-            _liveSessions.delete(session.id);
-            if (payload?.tag) _sessionIdByTag.delete(String(payload.tag));
-            // P1: sessions are one-shot in the shard (tag reuse routes here in
-            // P2). Close so a long-lived shard cannot accumulate live sessions.
-            try { mgr.closeSession(session.id, 'agent-shard-complete'); } catch { /* best-effort */ }
-        }
-    },
-    async cancel(payload) {
-        const rt = await boot();
-        const id = String(payload?.sessionId || '').trim()
-            || _sessionIdByTag.get(String(payload?.tag || '').trim())
-            || '';
-        if (!id) return { cancelled: false };
-        try { rt.mgr.closeSession(id, 'agent-shard-cancel'); } catch { /* best-effort */ }
-        return { cancelled: true };
-    },
-    // Tag-reuse routing (P2): a same-tag spawn/send while this shard runs the
-    // session queues the prompt into the live loop, mirroring the in-process
-    // busy-session enqueue path.
-    async enqueue(payload) {
-        const rt = await boot();
-        const id = String(payload?.sessionId || '').trim()
-            || _sessionIdByTag.get(String(payload?.tag || '').trim())
-            || '';
-        const session = id ? rt.mgr.getSession(id) : null;
-        if (!session || session.closed === true || !_liveSessions.has(id)) {
-            return { queued: false };
-        }
-        const prompt = String(payload?.prompt || '');
-        if (!prompt.trim()) return { queued: false };
-        const depth = rt.mgr.enqueuePendingMessage(id, prompt);
-        return { queued: true, sessionId: id, queueDepth: Math.max(1, Number(depth) || 1) };
-    },
-    // Cooldown broadcast from the lead (originating from the lead's own 429
-    // or a sibling shard's report). applyExternalCooldown never re-emits, so
-    // broadcasts cannot loop.
-    async cooldown(payload) {
-        const rt = await boot();
-        if (payload?.type === 'reset') {
-            rt.admissionMod.providerAdmissionScheduler.resetCooldowns(payload.provider || null);
-            return { applied: true };
-        }
-        const applied = rt.admissionMod.providerAdmissionScheduler.applyExternalCooldown?.(
-            payload?.key,
-            payload?.cooldownUntil,
-        ) === true;
-        return { applied };
-    },
-};
-
-// tag → live shard session id (cancel-by-tag; lead learns sessionId only at completion).
-const _sessionIdByTag = new Map();
-
-process.on('message', (msg) => {
-    if (!msg || typeof msg !== 'object') return;
-    const { type, callId, payload } = msg;
-    if (type === 'lead-tool-result') {
-        const item = _leadCalls.get(callId);
-        if (!item) return;
-        _leadCalls.delete(callId);
-        clearTimeout(item.timer);
-        if (msg.error != null) item.reject(new Error(msg.error));
-        else item.resolve(msg.result);
-        return;
-    }
-    const op = ops[type];
-    if (typeof op !== 'function') {
-        if (callId) send({ type: 'result', callId, error: `agent shard: unknown op "${type}"` });
-        return;
-    }
-    const ctx = {
-        progress: (event, extra) => {
-            if (callId) send({ type: 'progress', callId, event, payload: extra });
-        },
-    };
-    Promise.resolve()
-        .then(() => op(payload, ctx))
-        .then(
-            (result) => { if (callId) send({ type: 'result', callId, result }); },
-            (error) => { if (callId) send({ type: 'result', callId, error: error?.message || String(error) }); },
-        );
-});
-
-// Parent death → no owner: exit rather than run headless forever.
-process.on('disconnect', () => process.exit(0));
-
-send({ type: 'ready', pid: process.pid });