mixdog 0.9.85 → 0.9.86

package/src/standalone/agent-tool.mjs

@@ -59,6 +59,7 @@ import {
 } from './agent-tool/worker-rows.mjs';
 import { resolveAgentTerminalReapMs } from '../session-runtime/config-helpers.mjs';
 import { createWorkerIndex } from './agent-tool/worker-index.mjs';
+import { agentShardEnabled, shardRequest } from './agent-shard/shard-pool.mjs';
 import {
   beginAgentTurnReview,
   completeAgentTurnReview,
@@ -734,6 +735,17 @@ export function createStandaloneAgent({
         if (currentMeta?.sessionId) {
           try { mgr.closeSession(currentMeta.sessionId, 'agent-task-cancel'); } catch {}
         }
+        // Sharded spawn: the live session exists only in the shard child —
+        // forward the cancel by sessionId (known after the `spawned` progress
+        // event) or tag.
+        if (agentShardEnabled() && (currentMeta?.tag || currentMeta?.sessionId)) {
+          try {
+            void shardRequest('cancel', {
+              tag: currentMeta?.tag || null,
+              sessionId: currentMeta?.sessionId || null,
+            }).catch(() => {});
+          } catch { /* best-effort */ }
+        }
       },
       run: async () => {
         const lease = await resourceAdmission.acquire('agent', {
@@ -758,6 +770,13 @@ export function createStandaloneAgent({
   function startDeferredSpawnJob(args, callerCwd, context, notifyContext, extras = {}) {
     return startJob('spawn', pendingSpawnMeta(args, extras), async (job) => {
       if (job?.status === 'cancelled') return null;
+      // P1 agent sharding (MIXDOG_AGENT_SHARD=1, default off): run the worker
+      // session in a shard child process instead of this event loop. Prompt
+      // resolution stays here (cheap); prep + the full agent loop run in the
+      // shard. Tag/index/watchdog parity lands in P2 (docs/agent-shard-design.md).
+      if (agentShardEnabled()) {
+        return await runShardSpawn(args, callerCwd, context, job);
+      }
       // prepareSpawn (ensureProvider/prepareAgentSession) runs before runSpawn
       // installs its progress watchdog, so guard prep with an internal env-
       // backed cap rather than exposing per-call timeout knobs on the agent
@@ -816,7 +835,199 @@ export function createStandaloneAgent({
     progressWatchdogs.start(sessionId, watchdogPolicy, agent);
 
   async function prepareSpawn(args, callerCwd = null, context = {}, prepState = null) {
+    // (sharded spawns never reach here — see startDeferredSpawnJob)
     refreshTagsFromSessions({ context });
+    return prepareSpawnInProcess(args, callerCwd, context, prepState);
+  }
+
+  // Tag-reuse routing for sharded workers (P2): a same-tag spawn/send while
+  // the shard runs the session mirrors the in-process busy-session enqueue.
+  // Discriminator: a non-terminal worker-index row whose session has no live
+  // runtime in THIS process. (mgr.getSession must not be used here — it
+  // falls back to the on-disk session file the shard child persists, which
+  // makes a shard-owned session look lead-live.) Returns the rendered queued
+  // result, or null to fall through to the normal path (unknown tag,
+  // terminal row, lead-owned runtime, or the shard no longer owns the
+  // session — e.g. after a shard crash, where respawn is the correct
+  // recovery).
+  async function tryShardEnqueue(target, args, context, extras = {}) {
+    if (!agentShardEnabled()) return null;
+    const value = clean(target);
+    if (!value) return null;
+    const row = readWorkerRows(context).find((r) => (
+      (clean(r.tag) === value || clean(r.sessionId) === value)
+      && rowMatchesContext(r, context)
+      && !isTerminalWorkerStatus(r.status || r.stage)
+    ));
+    if (!row) return null;
+    const rowSessionId = clean(row.sessionId);
+    const runtime = rowSessionId ? mgr.getSessionRuntime?.(rowSessionId) : null;
+    if (runtime?.controller?.signal && !runtime.controller.signal.aborted) return null;
+    const prompt = await resolvePrompt(args, clean(row.cwd) || defaultCwd || process.cwd());
+    if (!clean(prompt)) return null;
+    let queued = null;
+    try {
+      queued = await shardRequest('enqueue', {
+        tag: clean(row.tag) || null,
+        sessionId: rowSessionId || null,
+        prompt,
+      });
+    } catch { return null; }
+    if (queued?.queued !== true) return null;
+    return renderResult({
+      queued: true,
+      ...extras,
+      tag: clean(row.tag) || null,
+      sessionId: rowSessionId || null,
+      agent: clean(row.agent) || null,
+      queueDepth: queued.queueDepth || 1,
+    });
+  }
+
+  async function runShardSpawn(args, callerCwd, context, job) {
+    const agent = normalizeAgentName(args.agent);
+    if (!agent) throw new Error('agent spawn: agent is required');
+    const tag = clean(args.tag) || nextTag(agent, context);
+    const baseCwd = resolve(callerCwd || defaultCwd || process.cwd());
+    const workerCwd = clean(args.cwd) ? resolve(baseCwd, args.cwd) : baseCwd;
+    const prompt = withCwdHeader(await resolvePrompt(args, workerCwd), workerCwd);
+    const clientHostPid = terminalPidForContext(context) || null;
+    // P2 progress parity: the shard reports the bound session the moment it
+    // exists (`spawned`), so the lead mirrors its in-process spawn
+    // bookkeeping — tag maps, worker-index row, statusline route, job meta,
+    // SubagentStart — while the worker loop runs in the child.
+    let spawned = null;
+    const onSpawned = (payload = {}) => {
+      if (spawned || !payload.sessionId) return;
+      spawned = payload;
+      const sessionLike = {
+        id: payload.sessionId,
+        agent,
+        cwd: payload.cwd || workerCwd,
+        provider: payload.provider || null,
+        model: payload.model || null,
+        presetName: payload.presetName || null,
+        effort: payload.effort || null,
+        fast: payload.fast === true,
+        clientHostPid,
+        status: 'running',
+      };
+      cancelReap(payload.sessionId);
+      writeAgentStatuslineRoute(payload.sessionId, {
+        provider: payload.provider || null,
+        model: payload.model || null,
+        effort: payload.effort || null,
+        fast: payload.fast === true,
+      });
+      bindTag(tag, sessionLike, {
+        agent,
+        preset: payload.presetName || null,
+        provider: payload.provider || null,
+        model: payload.model || null,
+        effort: payload.effort || null,
+        fast: payload.fast === true,
+        status: 'running',
+        stage: 'running',
+      });
+      if (job) {
+        mergeJobMeta(job, {
+          tag,
+          sessionId: payload.sessionId,
+          agent,
+          preset: payload.presetName || null,
+          provider: payload.provider || null,
+          model: payload.model || null,
+          effort: payload.effort || null,
+          fast: payload.fast === true,
+        });
+      }
+      emitSubagentEvent('start', agent, { session_id: payload.sessionId, tag });
+      // Cancel raced the shard prep: the task is already terminal on the lead
+      // but the child just started its loop — abort it now that the sessionId
+      // is known, instead of letting it burn tokens to completion.
+      if (job?.status === 'cancelled') {
+        try { void shardRequest('cancel', { tag, sessionId: payload.sessionId }).catch(() => {}); } catch { /* best-effort */ }
+      }
+    };
+    let finalStatus = 'error';
+    try {
+      const response = await shardRequest('spawn', {
+        args: {
+          agent,
+          provider: args.provider,
+          model: args.model,
+          effort: args.effort,
+          fast: args.fast,
+          preset: args.preset,
+        },
+        tag,
+        cwd: workerCwd,
+        prompt,
+        context: args.context || null,
+        parentSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
+        ownerSessionId: clean(context?.callerSessionId || context?.sessionId) || null,
+        clientHostPid,
+      }, {
+        onProgress: (event, payload) => { if (event === 'spawned') onSpawned(payload); },
+      });
+      // Same abnormal-empty promotion as the in-process completionValue; a
+      // watchdog partial handoff (stallAbort) is a valid completion and is
+      // exempt, matching runSpawn's catch path.
+      const abnormalError = response?.stallAbort === true
+        ? null
+        : abnormalEmptyFinishError(response, agent);
+      const value = {
+        tag,
+        sessionId: response.sessionId,
+        agent,
+        preset: response.presetName || null,
+        provider: response.provider || null,
+        model: response.model || null,
+        effort: response.effort || null,
+        fast: response.fast === true,
+        content: response.content || '',
+        ...(response.stallAbort === true ? { stallAbort: true } : {}),
+        ...(abnormalError ? { error: abnormalError } : {}),
+      };
+      if (job) job._terminalResultValue = value;
+      if (value.error) throw new Error(value.error);
+      finalStatus = 'idle';
+      return value;
+    } finally {
+      // Terminal bookkeeping parity with runSpawn's finally: worker-index row
+      // transitions to idle/error, the terminal-reap timer starts (tombstone +
+      // statusline cleanup), and SubagentStop fires. Only after `spawned` —
+      // a prep failure inside the shard bound nothing on the lead.
+      if (spawned?.sessionId) {
+        upsertWorkerSessionDeferred({
+          id: spawned.sessionId,
+          agent,
+          cwd: spawned.cwd || workerCwd,
+          provider: spawned.provider || null,
+          model: spawned.model || null,
+          presetName: spawned.presetName || null,
+          effort: spawned.effort || null,
+          fast: spawned.fast === true,
+          clientHostPid,
+          status: finalStatus,
+        }, tag, {
+          agent,
+          preset: spawned.presetName || null,
+          provider: spawned.provider || null,
+          model: spawned.model || null,
+          effort: spawned.effort || null,
+          fast: spawned.fast === true,
+          status: finalStatus,
+          stage: finalStatus,
+          finishedAt: new Date().toISOString(),
+        });
+        scheduleReap(spawned.sessionId, spawned.provider || null);
+        emitSubagentEvent('stop', agent, { session_id: spawned.sessionId, tag, status: finalStatus });
+      }
+    }
+  }
+
+  async function prepareSpawnInProcess(args, callerCwd = null, context = {}, prepState = null) {
     const config = cfgMod.loadConfig();
     const agent = normalizeAgentName(args.agent);
     if (!agent) throw new Error('agent spawn: agent is required');
@@ -1377,6 +1588,11 @@ export function createStandaloneAgent({
       if (type === 'cancel') return renderResult(close(args, scopedContext));
       if (type === 'close') return renderResult(close(args, scopedContext));
       if (type === 'send') {
+        // Sharded busy worker: queue the follow-up into the shard-owned live
+        // session (in-process busy sessions are handled below via
+        // dispatchToExistingSession; their lead session resolves live).
+        const shardQueued = await tryShardEnqueue(clean(args.tag || args.sessionId), args, scopedContext);
+        if (shardQueued) return shardQueued;
         try {
           const prepared = await prepareSend(args, scopedContext);
           return dispatchToExistingSession(prepared, notifyContext);
@@ -1449,6 +1665,12 @@ export function createStandaloneAgent({
         let respawned = false;
         let spawnArgs = args;
         if (explicitTag) {
+          // Sharded busy worker under this tag: queue into the shard-owned
+          // live session BEFORE the live-reuse resolve — the lead's disk-read
+          // session view would otherwise misroute this into an in-process
+          // send against a shard-owned session file (dual writer).
+          const shardQueued = await tryShardEnqueue(explicitTag, args, scopedContext, { reused: true });
+          if (shardQueued) return shardQueued;
           // Resolve a LIVE same-tag session in this terminal (busy or idle).
           let liveSessionId = null;
           try {