mixdog 0.7.11 → 0.7.13

package/scripts/run-mcp.mjs

@@ -26,6 +26,8 @@ import {
   ensureRuntimeDeps,
   hasRequiredDeps,
   renameWithRetrySync,
+  RENAME_RETRY_CODES,
+  sleepSync,
 } from './ensure-deps.mjs';
 
 // Stable per-terminal session id for this proxy supervisor's lifetime. The
@@ -453,6 +455,12 @@ let childHasResponded    = false;
 let announceListChangedOnReady = false;
 let cachedInitRequest    = null; // { id, params } from client's first initialize
 let cachedInitDone       = false; // initialized notification observed from client
+// One-shot latch: flips true the instant the client's initialize response is
+// forwarded and never resets. It selects replayInitToChild's mode (real-id vs
+// swallow) and tells handleChildGone whether the pending initialize may be
+// flushed. Until it is true the client has NOT seen its initialize result, so
+// that request must survive a child death and be re-driven, not errored.
+let clientInitAnswered   = false;
 let internalIdSeq        = -1;    // negative ids reserved for supervisor-internal requests
 const pendingFromClient  = new Map(); // request id (from client) → { method }
 const pendingInternal    = new Set(); // internal ids (init replay) — drop responses
@@ -670,14 +678,33 @@ function flushPendingClientErrors(tag) {
 
 function replayInitToChild() {
   if (!cachedInitRequest) return;
-  const internalId = internalIdSeq--;
-  pendingInternal.add(internalId);
-  writeToChild(JSON.stringify({
-    jsonrpc: '2.0',
-    id: internalId,
-    method: 'initialize',
-    params: cachedInitRequest.params,
-  }));
+  // Mode select by invariant — has the client's initialize been answered yet?
+  //  • Already answered (steady-state respawn): the client is fully
+  //    initialized and must NOT see a second result. Replay under an internal
+  //    negative id and swallow the response.
+  //  • Not yet (first-boot / handshake-time crash): replay under the client's
+  //    OWN id. Its request is still pending (preserved across the child-gone
+  //    flush in handleChildGone), so the new child's initialize response flows
+  //    back through the normal forward path — the client sees one clean result
+  //    instead of the -32603 that previously killed the connection and forced
+  //    a manual /mcp reconnect.
+  if (clientInitAnswered) {
+    const internalId = internalIdSeq--;
+    pendingInternal.add(internalId);
+    writeToChild(JSON.stringify({
+      jsonrpc: '2.0',
+      id: internalId,
+      method: 'initialize',
+      params: cachedInitRequest.params,
+    }));
+  } else {
+    writeToChild(JSON.stringify({
+      jsonrpc: '2.0',
+      id: cachedInitRequest.id,
+      method: 'initialize',
+      params: cachedInitRequest.params,
+    }));
+  }
   if (cachedInitDone) {
     // Notification — no id, no response expected.
     writeToChild(JSON.stringify({
@@ -816,7 +843,13 @@ function handleChildLine(line) {
     for (const item of scanned) {
       if (item && item.id !== undefined) {
         if (pendingInternal.has(item.id)) { internalIds.add(item.id); pendingInternal.delete(item.id); _maybeResolveLivenessPong(item.id); }
-        else { pendingFromClient.delete(item.id); }
+        else {
+          pendingFromClient.delete(item.id);
+          // Same latch as the scalar path below — keep the invariant consistent
+          // even if the client's initialize ever returns inside a batch, so a
+          // later respawn swallows its replay instead of re-driving the real id.
+          if (cachedInitRequest && item.id === cachedInitRequest.id) clientInitAnswered = true;
+        }
       }
     }
     if (internalIds.size) {
@@ -846,6 +879,10 @@ function handleChildLine(line) {
       return;
     }
     pendingFromClient.delete(scanned.id);
+    // The client's initialize is satisfied the instant its response is
+    // forwarded. Latch it so the next respawn swallows its replay (steady
+    // state) and so handleChildGone is free to error this id on a later death.
+    if (cachedInitRequest && scanned.id === cachedInitRequest.id) clientInitAnswered = true;
   }
   writeToClient(line);
 }
@@ -896,10 +933,29 @@ function handleChildGone(why) {
   }
   const _pendingClientAtGone = pendingFromClient.size;
   const _pendingInternalAtGone = pendingInternal.size;
+  // First-boot recovery invariant: the client's initialize must receive exactly
+  // one success response, from whichever child completes the handshake. If it
+  // has not been answered yet (clientInitAnswered=false), erroring it here makes
+  // the client mark the MCP server failed — it never re-issues initialize on its
+  // own, and the replay (internal id) never reaches it. That is the "startup
+  // fails, /mcp fixes it" symptom. Keep that single id pending across the flush;
+  // replayInitToChild re-drives it under the client's own id against the fresh
+  // child so the success response flows straight back. shuttingDown never
+  // preserves (the supervisor is exiting; nothing will replay).
+  const _preserveInitId = (!shuttingDown && !clientInitAnswered && cachedInitRequest)
+    ? cachedInitRequest.id
+    : undefined;
+  const _preservedInit = _preserveInitId !== undefined
+    ? pendingFromClient.get(_preserveInitId)
+    : undefined;
   for (const [id] of pendingFromClient) {
+    if (id === _preserveInitId) continue;
     sendErrorToClient(id, -32603, `[run-mcp] mcp child ${why.tag}; retry`);
   }
   pendingFromClient.clear();
+  if (_preserveInitId !== undefined && _preservedInit !== undefined) {
+    pendingFromClient.set(_preserveInitId, _preservedInit);
+  }
   pendingInternal.clear();
   // Fresh child = fresh response path; discard any in-flight liveness probe.
   _livenessPingId = null;

package/scripts/statusline-launcher-smoke.mjs

@@ -27,7 +27,7 @@ const tmp = mkdtempSync(join(tmpdir(), 'mixdog-sl-launcher-'));
 function run(homeDir) {
   return spawnSync(process.execPath, [LAUNCHER], {
     input: SAMPLE,
-    env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir },
+    env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir, CLAUDE_CONFIG_DIR: join(homeDir, '.claude') },
     encoding: 'utf8',
   });
 }
@@ -60,7 +60,7 @@ try {
     + "process.stdout.write(await renderStatusLine(i));\n"
   );
   const directRun = spawnSync(process.execPath, [driver],
-    { input: SAMPLE, env: { ...process.env, HOME: tmp, USERPROFILE: tmp }, encoding: 'utf8' });
+    { input: SAMPLE, env: { ...process.env, HOME: tmp, USERPROFILE: tmp, CLAUDE_CONFIG_DIR: join(tmp, '.claude') }, encoding: 'utf8' });
   const direct = directRun.stdout || '';
 
   const ok = run(tmp);

package/scripts/webhook-selfheal-smoke.mjs

@@ -5,9 +5,7 @@
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-if (!process.env.CLAUDE_PLUGIN_DATA) {
-  process.env.CLAUDE_PLUGIN_DATA = join(tmpdir(), `mixdog-webhook-selfheal-smoke-${process.pid}`);
-}
+process.env.CLAUDE_PLUGIN_DATA = join(tmpdir(), `mixdog-webhook-selfheal-smoke-${process.pid}`);
 
 const { decidePortReclaimAction } = await import('../src/channels/lib/webhook.mjs');
 

package/server-main.mjs

@@ -1040,10 +1040,62 @@ async function _getBridgeLlmFactory() {
 // completion after the worker stopped waiting for the result.
 const AGENT_IPC_MAX_CONCURRENT = 2
 const _agentIpcInflight = new Map()
-/** @type {Array<{ msg: object, worker: string, proc: import('child_process').ChildProcess }>} */
+/** @type {Array<{ msg: object, worker: string, proc: import('child_process').ChildProcess, lane?: string }>} */
 const _agentIpcQueue = []
 let _agentIpcRunning = 0
 
+const AGENT_IPC_LANE_USER = 'user'
+const AGENT_IPC_LANE_MAINTENANCE = 'maintenance'
+/** @type {Set<string>} */
+const AGENT_IPC_MAINTENANCE_WORKERS = new Set(['memory'])
+
+function _normalizeAgentIpcLaneToken(v) {
+  return typeof v === 'string' ? v.trim().toLowerCase() : ''
+}
+
+function _isMaintenanceBridgeRole(role) {
+  const r = _normalizeAgentIpcLaneToken(role)
+  if (!r) return false
+  if (r === 'maintenance' || r === 'scheduler-task' || r === 'webhook-handler' || r === 'memory-classification') {
+    return true
+  }
+  if (r.startsWith('cycle')) return true
+  return false
+}
+
+/** @returns {'user'|'maintenance'} */
+function _classifyAgentIpcJobLane(msg, worker) {
+  const lane = _normalizeAgentIpcLaneToken(msg?.lane)
+  if (lane === AGENT_IPC_LANE_MAINTENANCE || lane === 'maint') return AGENT_IPC_LANE_MAINTENANCE
+  if (lane === AGENT_IPC_LANE_USER) return AGENT_IPC_LANE_USER
+
+  const priority = _normalizeAgentIpcLaneToken(msg?.priority)
+  if (priority === AGENT_IPC_LANE_MAINTENANCE || priority === 'maint') return AGENT_IPC_LANE_MAINTENANCE
+  if (priority === AGENT_IPC_LANE_USER) return AGENT_IPC_LANE_USER
+
+  if (msg?.maintenance === true || msg?.isMaintenance === true) return AGENT_IPC_LANE_MAINTENANCE
+
+  const params = msg?.params && typeof msg.params === 'object' ? msg.params : {}
+  if (_isMaintenanceBridgeRole(params.role)) return AGENT_IPC_LANE_MAINTENANCE
+
+  const w = _normalizeAgentIpcLaneToken(worker)
+  if (AGENT_IPC_MAINTENANCE_WORKERS.has(w)) return AGENT_IPC_LANE_MAINTENANCE
+
+  return AGENT_IPC_LANE_USER
+}
+
+function _dequeueHighestPriorityAgentIpcJob() {
+  if (_agentIpcQueue.length === 0) return null
+  for (let i = 0; i < _agentIpcQueue.length; i++) {
+    const job = _agentIpcQueue[i]
+    const lane = job.lane || _classifyAgentIpcJobLane(job.msg, job.worker)
+    if (lane !== AGENT_IPC_LANE_MAINTENANCE) {
+      return _agentIpcQueue.splice(i, 1)[0]
+    }
+  }
+  return _agentIpcQueue.shift()
+}
+
 function _sendAgentIpcResponse(proc, callId, body) {
   try { proc.send({ type: 'agent_ipc_response', callId, ...body }) } catch {}
 }
@@ -1066,14 +1118,16 @@ function _startAgentIpcJob(job) {
 
 function _drainAgentIpcQueue() {
   while (_agentIpcRunning < AGENT_IPC_MAX_CONCURRENT && _agentIpcQueue.length > 0) {
-    const job = _agentIpcQueue.shift()
+    const job = _dequeueHighestPriorityAgentIpcJob()
+    if (!job) break
     _agentIpcRunning++
     _startAgentIpcJob(job)
   }
 }
 
 function _enqueueAgentIpcRequest(msg, worker, proc) {
-  _agentIpcQueue.push({ msg, worker, proc })
+  const lane = _classifyAgentIpcJobLane(msg, worker)
+  _agentIpcQueue.push({ msg, worker, proc, lane })
   _drainAgentIpcQueue()
 }