mixdog 0.7.11 → 0.7.12

package/scripts/mutation-io-smoke.mjs

@@ -70,7 +70,23 @@ async function warmRead(path, scope, offset = 0, limit = 20) {
 }
 
 async function rmTree(path) {
-  await rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+  // Windows CI occasionally keeps a just-used temp file locked briefly after the
+  // owning JS/native subprocess exits (EACCES/EBUSY/EPERM). Cleanup is not part
+  // of the smoke invariant, so retry with backoff and make final teardown
+  // best-effort instead of turning a passed mutation suite red.
+  const delays = [50, 100, 200, 400, 800];
+  let lastErr = null;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await rm(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (!['EACCES', 'EBUSY', 'EPERM', 'ENOTEMPTY'].includes(err?.code)) break;
+      if (i < delays.length) await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+  }
+  console.warn(`mutation-io smoke cleanup warning: failed to remove ${path}: ${lastErr?.code || ''} ${lastErr?.message || lastErr}`);
 }
 
 try {

package/scripts/permission-eval-smoke.mjs

@@ -10,6 +10,23 @@ import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 
+// The evaluator intentionally merges user-global Claude settings. Local dev
+// machines commonly have defaultMode=bypassPermissions, which made this smoke
+// pass locally while CI's empty user config exercised stricter defaults. Pin
+// the user tier to a throwaway Claude config dir so the smoke is hermetic and
+// still verifies the intended invariant: hard-deny and explicit list rules win
+// before bypass mode.
+const smokeHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'perm-smoke-home-')));
+const smokeConfigDir = path.join(smokeHome, '.claude');
+fs.mkdirSync(smokeConfigDir, { recursive: true });
+fs.writeFileSync(
+  path.join(smokeConfigDir, 'settings.json'),
+  JSON.stringify({ permissions: { defaultMode: 'bypassPermissions' } }),
+);
+process.env.HOME = smokeHome;
+process.env.USERPROFILE = smokeHome;
+process.env.CLAUDE_CONFIG_DIR = smokeConfigDir;
+
 const _require = createRequire(import.meta.url);
 const evalPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../hooks/lib/permission-evaluator.cjs');
 const { evaluatePermission } = _require(evalPath);
@@ -21,7 +38,7 @@ const { loadPermissions, clearSettingsCache } = _require(loaderPath);
 let pass = 0, fail = 0;
 
 function makeProject(settings = {}) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'perm-smoke-'));
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'perm-smoke-')));
   fs.mkdirSync(path.join(dir, '.claude'), { recursive: true });
   if (Object.keys(settings).length) {
     fs.writeFileSync(

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()
 }