mixdog 0.9.85 → 0.9.87

package/src/runtime/agent/orchestrator/tools/token-binary-fetcher.mjs

@@ -0,0 +1,201 @@
+// token-binary-fetcher.mjs — fetches the prebuilt mixdog-token native binary
+// from the GitHub release manifest. Token counting has an in-process WASM
+// fallback, so callers treat fetch failures as a soft degrade (never a tool
+// error). Caches under <dataDir>/token-bin/. Mirrors graph-binary-fetcher.mjs.
+//
+// Public API:
+//   ensureTokenBinary(dataDir) -> absolute path to the verified binary.
+//     Throws on no-asset / download / verify failure.
+//   findCachedTokenBinary(dataDir) -> path | null (sync, no network).
+// Both accept an optional dependency object used by deterministic tests:
+//   { bundledManifest, download }.
+
+import { createHash } from 'node:crypto';
+import {
+  chmodSync, createWriteStream, existsSync, mkdirSync,
+  readFileSync, readdirSync, renameSync, rmSync,
+} from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pipeline } from 'node:stream/promises';
+
+const BUNDLED_MANIFEST_PATH = fileURLToPath(new URL('./token-manifest.json', import.meta.url));
+const MANIFEST_URL = 'https://raw.githubusercontent.com/tribgames/mixdog/main/src/runtime/agent/orchestrator/tools/token-manifest.json';
+
+function binSuffix() {
+  return process.platform === 'win32' ? '.exe' : '';
+}
+
+function platformKey() {
+  const os = process.platform === 'win32' ? 'win32' : process.platform;
+  return `${os}-${process.arch}`;
+}
+
+function tokenBinDir(dataDir) {
+  return join(dataDir, 'token-bin');
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+function manifestVersion(manifest) {
+  const value = String(manifest?.version || '');
+  if (!/^\d+\.\d+\.\d+$/.test(value)) return null;
+  return value.split('.').map(Number);
+}
+
+function compareManifestVersions(a, b) {
+  const av = manifestVersion(a);
+  const bv = manifestVersion(b);
+  if (!av || !bv) return null;
+  for (let i = 0; i < 3; i++) {
+    if (av[i] !== bv[i]) return av[i] > bv[i] ? 1 : -1;
+  }
+  return 0;
+}
+
+function validSha256(value) {
+  return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value);
+}
+
+function validCachedUpgrade(manifest, pkey) {
+  if (!manifestVersion(manifest)) return false;
+  const asset = manifest.assets?.[pkey];
+  if (!asset || !validSha256(asset.sha256) || typeof asset.url !== 'string') return false;
+  const expectedUrl = `https://github.com/tribgames/mixdog/releases/download/token-v${manifest.version}`
+    + `/mixdog-token-${pkey}${binSuffix()}`;
+  return asset.url === expectedUrl;
+}
+
+function bundledManifest(options) {
+  if (options.bundledManifest) return options.bundledManifest;
+  return existsSync(BUNDLED_MANIFEST_PATH) ? readJson(BUNDLED_MANIFEST_PATH) : null;
+}
+
+function selectLocalManifest(dataDir, options = {}) {
+  const bundled = bundledManifest(options);
+  const cached = join(tokenBinDir(dataDir), 'manifest.json');
+  const cachedManifest = existsSync(cached) ? readJson(cached) : null;
+  if (bundled) {
+    // The installed manifest is the minimum policy. A cache may advance it,
+    // but only with a strict newer semver and a trusted, fully hashed asset.
+    if (compareManifestVersions(cachedManifest, bundled) === 1
+      && validCachedUpgrade(cachedManifest, platformKey())) {
+      return cachedManifest;
+    }
+    return bundled;
+  }
+  return validCachedUpgrade(cachedManifest, platformKey()) ? cachedManifest : null;
+}
+
+async function loadManifest(dataDir, options = {}) {
+  const local = selectLocalManifest(dataDir, options);
+  if (local) return local;
+  const fetchFn = options.fetch || fetch;
+  const res = await fetchFn(MANIFEST_URL, { signal: AbortSignal.timeout(30_000) });
+  if (!res.ok) {
+    throw new Error(`[token-fetcher] manifest fetch failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+async function sha256File(filePath) {
+  return createHash('sha256').update(await readFile(filePath)).digest('hex');
+}
+
+async function downloadWithRetry(url, destPath) {
+  const delays = [1000, 3000, 9000];
+  let lastErr;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(180_000) });
+      if (res.status >= 400 && res.status < 500) {
+        throw new Error(`[token-fetcher] asset HTTP ${res.status} (terminal) — ${url}`);
+      }
+      if (!res.ok) throw new Error(`[token-fetcher] asset HTTP ${res.status} — ${url}`);
+      await pipeline(res.body, createWriteStream(destPath));
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (String(err?.message || '').includes('(terminal)')) throw err;
+      if (attempt < 3) {
+        process.stderr.write(`[token-fetcher] download attempt ${attempt + 1} failed (${err?.message}), retrying in ${delays[attempt]}ms…\n`);
+        await new Promise((r) => setTimeout(r, delays[attempt]));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+function gcTokenBin(dir, keepFile) {
+  try {
+    for (const name of readdirSync(dir)) {
+      if (name === 'manifest.json' || name === keepFile) continue;
+      if (name.startsWith('mixdog-token')) {
+        try { rmSync(join(dir, name), { force: true }); } catch { /* best-effort */ }
+      }
+    }
+  } catch { /* dir may not exist yet */ }
+}
+
+export function findCachedTokenBinary(dataDir, options = {}) {
+  try {
+    const dir = tokenBinDir(dataDir);
+    const manifest = selectLocalManifest(dataDir, options);
+    const asset = manifest?.assets?.[platformKey()];
+    const version = manifestVersion(manifest);
+    if (!version || !validSha256(asset?.sha256)) return null;
+    const fileName = `mixdog-token-${manifest.version}${binSuffix()}`;
+    const hit = join(dir, fileName);
+    if (!existsSync(hit)) return null;
+    const actual = createHash('sha256').update(readFileSync(hit)).digest('hex');
+    return actual === asset.sha256.toLowerCase() ? hit : null;
+  } catch {
+    return null;
+  }
+}
+
+let _inflight = null;
+
+export function ensureTokenBinary(dataDir, options = {}) {
+  if (_inflight) return _inflight;
+  _inflight = (async () => {
+    const manifest = await loadManifest(dataDir, options);
+    const pkey = platformKey();
+    const asset = manifest.assets?.[pkey];
+    if (!asset || !asset.url || !validSha256(asset.sha256) || !manifestVersion(manifest)) {
+      // Unsupported platform/arch, or no token-v release published yet. The
+      // caller degrades to the in-process WASM worker, so the message only
+      // needs to explain why the accelerator is absent.
+      const supported = Object.keys(manifest.assets || {}).join(', ') || '(none)';
+      throw new Error(
+        `[token-fetcher] no prebuilt mixdog-token binary for platform ${pkey} `
+        + `(token counting degrades to the in-process WASM worker). `
+        + `Manifest platforms: ${supported}. `
+        + `Build it locally: cargo build --release in native/mixdog-token.`,
+      );
+    }
+    const version = String(manifest.version || '0');
+    const dir = tokenBinDir(dataDir);
+    mkdirSync(dir, { recursive: true });
+    const fileName = `mixdog-token-${version}${binSuffix()}`;
+    const destPath = join(dir, fileName);
+    if (existsSync(destPath)) {
+      try { if (await sha256File(destPath) === asset.sha256.toLowerCase()) return destPath; } catch { /* re-download */ }
+    }
+    const tmpPath = `${destPath}.tmp-${process.pid}-${Date.now()}`;
+    await (options.download || downloadWithRetry)(asset.url, tmpPath);
+    const actual = await sha256File(tmpPath);
+    if (actual !== asset.sha256.toLowerCase()) {
+      try { rmSync(tmpPath, { force: true }); } catch { /* best-effort */ }
+      throw new Error(`[token-fetcher] sha256 mismatch for ${pkey}: expected ${asset.sha256}, got ${actual}`);
+    }
+    renameSync(tmpPath, destPath);
+    if (process.platform !== 'win32') { try { chmodSync(destPath, 0o755); } catch { /* best-effort */ } }
+    gcTokenBin(dir, fileName);
+    return destPath;
+  })().finally(() => { _inflight = null; });
+  return _inflight;
+}

package/src/runtime/agent/orchestrator/tools/token-manifest.json

@@ -0,0 +1,26 @@
+{
+  "version": "0.1.0",
+  "_comment": "Synced from immutable token-v release assets.",
+  "assets": {
+    "darwin-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-darwin-arm64",
+      "sha256": "1d5259803207dd5ace466c506d8db4087460a20c1e3f4f6cc249832a8a996f6b"
+    },
+    "darwin-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-darwin-x64",
+      "sha256": "2212a434a89419ce0a4122ce4647e2feb2b4642e26d3e74e11b4de2819a6c2e3"
+    },
+    "linux-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-linux-arm64",
+      "sha256": "332839da398050218fbed4b6700a3e34dbdcba800893b9a3ba16ebca3e88b9ee"
+    },
+    "linux-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-linux-x64",
+      "sha256": "ac79201259985705cf378d225a25a779591d1f75fefd626e470b398e3d8fdd9c"
+    },
+    "win32-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-win32-x64.exe",
+      "sha256": "da6e39974811123b3e0c72f539c9e5b424261b66a3f2a30eb0e9cc837036d1ba"
+    }
+  }
+}

package/src/runtime/channels/lib/webhook/relay-tunnel.mjs

@@ -28,14 +28,14 @@ export function resolveHookRelayUrl(env = process.env) {
   return raw || DEFAULT_RELAY_URL;
 }
 
-export function hookIdentityPath() {
+function hookIdentityPath() {
   return join(DATA_DIR, "relay-hook-device.json");
 }
 
 // Stable per-install identity (trust-on-first-use at the relay, mirroring
 // the desktop leg). The secret never leaves this machine except toward the
 // relay; the deviceId doubles as the public URL path segment.
-export function loadOrCreateHookIdentity() {
+function loadOrCreateHookIdentity() {
   const path = hookIdentityPath();
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -58,7 +58,7 @@ export function loadOrCreateHookIdentity() {
   return identity;
 }
 
-export function hookPublicBase(relayUrl, deviceId) {
+function hookPublicBase(relayUrl, deviceId) {
   const url = new URL(relayUrl);
   url.protocol = url.protocol === "wss:" ? "https:" : "http:";
   url.pathname = `/hook/${deviceId}`;

package/src/runtime/media/adapters/gemini-video.mjs

@@ -16,7 +16,7 @@ const OMNI_TIMEOUT_MS = 600_000;
 const POLL_INTERVAL_MS = 8_000;
 const TOTAL_TIMEOUT_MS = 900_000;
 
-export function isOmniModel(model) {
+function isOmniModel(model) {
   return /omni/i.test(String(model || ''));
 }
 

package/src/runtime/media/renditions.mjs

@@ -30,7 +30,7 @@ const EXTENSION_MIME = { '.webp': 'image/webp', '.png': 'image/png' };
 const POSTER_TIMEOUT_MS = 20_000;
 const MAX_POSTER_BYTES = 32 * 1024 * 1024;
 
-export const MEDIA_VARIANTS = Object.keys(SPECS);
+const MEDIA_VARIANTS = Object.keys(SPECS);
 
 /** Spec for a variant name, or null when the caller asked for the original. */
 export function renditionSpec(variant) {

package/src/runtime/media/store.mjs

@@ -222,7 +222,7 @@ async function prewarmThumbs(assets) {
   await Promise.all(workers).catch(() => {});
 }
 
-export function getMediaAsset(id) {
+function getMediaAsset(id) {
   ensureDirs();
   return readIndex().find((entry) => entry.id === id) || null;
 }

package/src/runtime/memory/lib/memory-action-handlers.mjs

@@ -877,7 +877,10 @@ export function createMemoryActionHandlers({
       return { text: `retro_eval_active: total=${total} archived=${archived} kept=${kept} updated=${updated} merged=${merged} errors=${errors}` }
     }
 
-    return { text: `unknown memory action: ${action}`, isError: true }
+    return {
+      text: `unknown memory action: ${action}; valid: core, status. Mutation verbs belong in op.`,
+      isError: true,
+    }
   }
 
   const handleToolCall = createToolCallHandler({ handleSearch, handleMemoryAction })

package/src/runtime/memory/tool-defs.mjs

@@ -8,12 +8,24 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+summary; edit works by id alone.',
+    description: [
+      'Core-memory mutation/status; recall retrieves.',
+      'Mutations use action=core with op; status uses action=status.',
+      'Store only durable compact ENGLISH facts/rules/preferences.',
+    ].join(' '),
     inputSchema: {
       type: 'object',
       properties: {
-        action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
-        op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
+        action: {
+          type: 'string',
+          enum: ['core','status'],
+          description: 'core for mutations; status otherwise. Mutation verbs belong in op.',
+        },
+        op: {
+          type: 'string',
+          enum: ['add','edit','delete','list','candidates','promote','dismiss'],
+          description: 'Required for action=core.',
+        },
         id: { type: 'number', description: 'Exact memory id.' },
         element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
         summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, max 100 chars.' },
@@ -22,6 +34,10 @@ export const TOOL_DEFS = [
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
         project_id: { type: 'string', description: 'Core pool: explicit common or slug. Required for core add only (edit uses the id\'s stored pool); there is no default pool.' },
       },
+      anyOf: [
+        { properties: { action: { const: 'status' } }, required: ['action'] },
+        { properties: { action: { const: 'core' } }, required: ['action', 'op'] },
+      ],
       additionalProperties: false,
       required: ['action'],
     },

package/src/runtime/shared/atomic-file.mjs

@@ -118,10 +118,15 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
     } catch (err) {
       lastErr = err;
       if (!LOCK_WAIT_CODES.has(err?.code)) throw err;
-      // try-once semantics: timeoutMs:0 makes a single openSync attempt and
-      // never sleeps — on contention it throws ELOCKCONTENDED immediately so
-      // the main loop is never blocked by Atomics.wait. No stale-reclaim,
-      // since reclaim would require waiting on the guard.
+      // Reclaim is itself try-once: the guard is acquired atomically and never
+      // waited on. This lets timeoutMs:0 recover a dead/pidless corpse without
+      // weakening its no-sleep contract.
+      try {
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
+      } catch {}
+      // try-once semantics: timeoutMs:0 makes one guarded reclaim attempt and
+      // never sleeps — live contention throws ELOCKCONTENDED immediately so
+      // the main loop is never blocked by Atomics.wait.
       if (timeoutMs <= 0) {
         const contErr = new Error(`atomic lock contended (try-once): ${lockPath} [${_describeLockHolder(lockPath)}]`);
         contErr.code = 'ELOCKCONTENDED';
@@ -130,9 +135,6 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
       }
       // Reclaim only when owner death is positively established. Age, an
       // unreadable owner, or a same-pid foreign token remain contended.
-      try {
-        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
-      } catch {}
       if (Date.now() >= deadline) break;
       const base = DEFAULT_BACKOFFS_MS[Math.min(attempt, DEFAULT_BACKOFFS_MS.length - 1)];
       const jitter = Math.floor(Math.random() * Math.min(75, Math.max(1, base)));
@@ -223,14 +225,19 @@ function _lockOwnedBySelf(lockPath) {
 //
 // Reclaim decision table (owner = identity recorded in the lock file):
 //   owner pid DEAD (ESRCH) → reclaim
-//   owner pid NULL/uncertain or same-pid foreign token → back off
+//   owner pid NULL/uncertain and lock age >= staleMs → reclaim
+//   owner pid NULL/uncertain and lock age < staleMs → back off
+//   same-pid foreign token → back off
 //   owner token MISMATCH on guarded re-read (new holder took over) → back off
 //   owner LIVE → back off regardless of age
 function _tryReclaimStaleLock(lockPath, staleMs) {
-  try { statSync(lockPath); } catch { return false; }
+  let initial;
+  try { initial = statSync(lockPath); } catch { return false; }
   const owner = _readLockOwner(lockPath);
   const dead = owner.pid !== null && !_ownerIsLive(owner);
-  if (!dead) return false;
+  const pidlessStale = owner.pid === null
+    && Date.now() - (Number(initial.mtimeMs) || 0) >= Math.max(0, staleMs);
+  if (!dead && !pidlessStale) return false;
   const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
   if (reclaim === null) return false;
   try {
@@ -243,7 +250,9 @@ function _tryReclaimStaleLock(lockPath, staleMs) {
     // corpse — so we never yank a freshly-acquired live lock.
     if (curOwner.pid !== owner.pid || curOwner.token !== owner.token) return false;
     const curDead = curOwner.pid !== null && !_ownerIsLive(curOwner);
-    if (curDead) {
+    const curPidlessStale = curOwner.pid === null
+      && Date.now() - (Number(cur.mtimeMs) || 0) >= Math.max(0, staleMs);
+    if (curDead || curPidlessStale) {
       try { unlinkSync(lockPath); return true; } catch { return false; }
     }
     return false;
@@ -307,6 +316,11 @@ export async function withFileLock(lockPath, fn, opts = {}) {
     } catch (err) {
       lastErr = err;
       if (!LOCK_WAIT_CODES.has(err?.code)) throw err;
+      // The guarded reclaim is non-blocking, so try-once callers can recover
+      // stale corpses while still returning immediately for a live holder.
+      try {
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
+      } catch {}
       if (timeoutMs <= 0) {
         const contErr = new Error(`atomic lock contended (try-once): ${lockPath} [${_describeLockHolder(lockPath)}]`);
         contErr.code = 'ELOCKCONTENDED';
@@ -316,9 +330,6 @@ export async function withFileLock(lockPath, fn, opts = {}) {
       // Stale-lock reclaim (shared with the sync variant): dead owner pid,
       // a same-pid-but-foreign-token corpse from a reused pid, or a
       // pidless/empty corpse lock. A live foreign holder is never stolen.
-      try {
-        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
-      } catch {}
       if (Date.now() >= deadline) break;
       const base = DEFAULT_BACKOFFS_MS[Math.min(attempt, DEFAULT_BACKOFFS_MS.length - 1)];
       const jitter = Math.floor(Math.random() * Math.min(75, Math.max(1, base)));

package/src/runtime/shared/automation-attachments.mjs

@@ -7,11 +7,11 @@
  * {type:'file'}), so provider media normalization treats them identically.
  */
 
-export const AUTOMATION_ATTACHMENT_KINDS = ['image', 'text', 'pdf'];
+const AUTOMATION_ATTACHMENT_KINDS = ['image', 'text', 'pdf'];
 export const MAX_AUTOMATION_ATTACHMENTS = 8;
 // Base64 total across image/pdf items; text totals separately.
-export const MAX_AUTOMATION_BINARY_TOTAL = 8_000_000;
-export const MAX_AUTOMATION_TEXT_TOTAL = 200_000;
+const MAX_AUTOMATION_BINARY_TOTAL = 8_000_000;
+const MAX_AUTOMATION_TEXT_TOTAL = 200_000;
 
 /** Validate + strip a stored/list attachments value to the persisted shape (or null). */
 export function normalizeAutomationAttachments(value) {

package/src/runtime/shared/child-guardian.mjs

@@ -8,6 +8,20 @@ function positiveInt(value) {
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
+export function childGuardianSpawnEnv(env = process.env) {
+  return {
+    PATH: env.PATH || '',
+    SystemRoot: env.SystemRoot || env.WINDIR || '',
+    WINDIR: env.WINDIR || env.SystemRoot || '',
+    // Desktop's engine runs inside an Electron utility process, where
+    // process.execPath points at electron.exe. Without Node mode Electron
+    // ignores --eval, starts a full app process, and the intended guardian
+    // loop never runs — every completed shell then leaks ~100 MB until the
+    // desktop exits.
+    ELECTRON_RUN_AS_NODE: '1',
+  };
+}
+
 function guardianScript({ parentPid, childPid, childGroupPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
   return `
 const { spawnSync } = require('node:child_process');
@@ -88,11 +102,7 @@ export function startChildGuardian({
       }),
     ], {
       stdio: 'ignore',
-      env: {
-        PATH: process.env.PATH || '',
-        SystemRoot: process.env.SystemRoot || process.env.WINDIR || '',
-        WINDIR: process.env.WINDIR || process.env.SystemRoot || '',
-      },
+      env: childGuardianSpawnEnv(),
       ...detachedSpawnOpts,
     });
     guardian.unref?.();

package/src/runtime/shared/child-spawn-gate.mjs

@@ -3,25 +3,19 @@
 // ── Module-global child-spawn semaphore ──────────────────────────────────
 //
 // Single-daemon premise: tool execution is in-process, so a module-level
-// singleton semaphore bounds the number of concurrent child processes (rg,
-// mixdog-graph, …) across ALL agents/workers in this daemon. The goal is to
-// absorb the over-saturation tail — when N agents fire grep/code_graph at
-// once each child no longer fans out across every core, and the rg 20s
-// deadline stops tripping en masse — WITHOUT serializing: up to the cap run
-// concurrently, only the overflow queues and drains as slots free.
+// singleton semaphore CAN bound the number of concurrent child processes (rg,
+// mixdog-graph, …) across ALL agents/workers in this daemon. By default the
+// gate is UNBOUNDED — parallel waves must never queue behind it — and it only
+// becomes a real cap when MIXDOG_CHILD_SPAWN_MAX_INFLIGHT is set explicitly.
 //
 // IMPORTANT: this is a resource-control knob and is deliberately NOT exposed
 // on any tool JSON schema / tool parameter surface. The only tuning surface
-// is the internal constant + the MIXDOG_CHILD_SPAWN_MAX_INFLIGHT env override.
-
-import os from 'node:os';
+// is the MIXDOG_CHILD_SPAWN_MAX_INFLIGHT env override.
 
 function _defaultMaxInflight() {
   const override = Number(process.env.MIXDOG_CHILD_SPAWN_MAX_INFLIGHT);
   if (Number.isFinite(override) && override >= 1) return Math.floor(override);
-  let cpus = 0;
-  try { cpus = os.cpus()?.length || 0; } catch { cpus = 0; }
-  return Math.max(4, cpus || 4);
+  return Infinity;
 }
 
 const MAX_INFLIGHT = _defaultMaxInflight();

package/src/runtime/shared/resource-admission.mjs

@@ -4,10 +4,14 @@ import { requestMemoryPressureSnapshot } from './memory-snapshot.mjs';
 
 const MB = 1024 * 1024;
 
+// Concurrency defaults are UNBOUNDED by design: parallel agent/shell waves
+// must never serialize behind an admission queue. The only default guards are
+// the memory-pressure checks below; hard caps exist solely as opt-in env
+// overrides (MIXDOG_MAX_CONCURRENT_AGENTS / _SHELLS / _HIGH_LOAD).
 export const RESOURCE_ADMISSION_DEFAULTS = Object.freeze({
-  maxAgents: 4,
-  maxShells: 4,
-  maxHighLoad: 6,
+  maxAgents: Infinity,
+  maxShells: Infinity,
+  maxHighLoad: Infinity,
   maxQueue: 32,
   minFreeMemoryMb: 1024,
   maxRssMb: 3072,

package/src/runtime/shared/turn-snapshot.mjs

@@ -47,9 +47,6 @@ function publicAgentReviews(sessionId) {
   return [...turn.agents.values()].map((review) => ({ ...review }));
 }
 
-/** Compatibility no-op: apply_patch tracking has no project warmup cost. */
-export function prewarmTurnSnapshot() {}
-
 /** Start a new user turn and invalidate the prior turn's child review group. */
 export async function beginTurnSnapshot(_worktree, sessionId) {
   const ownerSessionId = clean(sessionId);

package/src/session-runtime/lifecycle-api.mjs

@@ -49,6 +49,7 @@ export function createLifecycleApi(deps) {
     createCurrentSession, refreshRouteEffort,
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, getStandaloneTools,
+    beginRoutePreparation, clearRoutePreparation,
     pushTranscriptRebind,
     notificationListeners, remoteStateListeners, desktopSession,
   } = deps;
@@ -342,7 +343,8 @@ export function createLifecycleApi(deps) {
       pushTranscriptRebind?.();
       return true;
     },
-    async switchContext({ cwd, desktopSession: nextDesktopSession } = {}) {
+    async switchContext({ cwd, desktopSession: nextDesktopSession, forResume = false } = {}) {
+      clearRoutePreparation?.();
       const session = getSession();
       if (session?.id) {
         const cleanupReason = 'desktop-context-switch';
@@ -376,7 +378,7 @@ export function createLifecycleApi(deps) {
       // that session's provider/model. A fresh desktop task or project must
       // return to the configured Lead route instead of inheriting the route
       // of whichever session happened to be open immediately beforehand.
-      if (typeof setRoute === 'function' && typeof getConfig === 'function'
+      if (!forResume && typeof setRoute === 'function' && typeof getConfig === 'function'
         && typeof resolveRoute === 'function') {
         setRoute(resolveRoute(getConfig(), {}));
         await refreshRouteEffort?.();
@@ -405,7 +407,23 @@ export function createLifecycleApi(deps) {
     prefetchSession(id) {
       return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
     },
+    // Read-only session peek (desktop split panes treat every visible pane as
+    // foreground): the parsed session object without resuming, attaching, or
+    // touching ownership/liveness. The current session returns live memory.
+    peekSession(id) {
+      const sessionId = clean(id);
+      if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId)) return null;
+      const current = getSession();
+      if (current?.id === sessionId) return current;
+      const session = mgr.loadSession?.(sessionId);
+      // `closed` means the previous live owner released this durable session;
+      // it is still a valid historical transcript. Desktop pane peeks are
+      // strictly read-only, so they may inspect it without resuming or
+      // changing ownership. Deleted/tombstoned sessions have no load result.
+      return session || null;
+    },
     async resume(id) {
+      clearRoutePreparation?.();
       const prev = getSession();
       const previousId = prev?.id || null;
       const previousMessages = prev?.messages || null;
@@ -430,22 +448,44 @@ export function createLifecycleApi(deps) {
       }
       setSession(resumed);
       applyResolvedCwd(resolveResumeCwd(resumed, getCurrentCwd()), { markRefresh: false });
+      // Cwd application is synchronous even though MCP reconnect may continue
+      // in the background. Commit it before returning the resume transcript.
+      resumed.cwd = getCurrentCwd();
       const route = getRoute();
       // The resumed session's OWN effort wins. resolveRoute always returns an
       // effort key, so this used to reinstate the effort of whichever session
       // happened to be open before — a schedule/webhook session opened with a
       // different effort than the one it actually ran with.
       const resumeEffort = resumed.effort || (hasOwn(route, 'effort') ? route.effort : undefined);
-      setRoute(resolveRoute(getConfig(), { provider: resumed.provider, model: resumed.model, effort: resumeEffort }));
-      await refreshRouteEffort();
-      const session = getSession();
-      session.effort = getRoute().effectiveEffort || null;
-      session.cwd = getCurrentCwd();
-      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), getStandaloneTools(), { provider: getRoute().provider });
+      const resumedRoute = resolveRoute(
+        getConfig(),
+        { provider: resumed.provider, model: resumed.model, effort: resumeEffort },
+      );
+      setRoute(resumedRoute);
+      const finishRoutePreparation = async () => {
+        const preparedRoute = await refreshRouteEffort(null, resumedRoute);
+        // Session or route changed while provider metadata was loading.
+        if (!preparedRoute || getSession() !== resumed || getRoute() !== preparedRoute) return false;
+        const activeSession = getSession();
+        activeSession.effort = getRoute().effectiveEffort || null;
+        activeSession.cwd = getCurrentCwd();
+        applyDeferredToolSurface(
+          activeSession,
+          deferredSurfaceModeForLead(getMode()),
+          getStandaloneTools(),
+          { provider: getRoute().provider },
+        );
+        writeStatuslineRoute(statusRoutes, activeSession, getRoute());
+        return true;
+      };
+      if (typeof beginRoutePreparation === 'function') {
+        beginRoutePreparation(finishRoutePreparation);
+      } else {
+        await finishRoutePreparation();
+      }
       invalidatePreSessionToolSurface();
       invalidateContextStatusCache();
       setSessionNeedsCwdRefresh(false);
-      writeStatuslineRoute(statusRoutes, session, getRoute());
       // Session swapped to the resumed one: repoint the worker to the current
       // transcript instead of waiting for the next inbound steal.
       pushTranscriptRebind?.();