mixdog 0.9.84 → 0.9.86

package/src/runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs

@@ -1,15 +1,14 @@
-import { spawnSync } from 'child_process';
 import { existsSync } from 'fs';
-import { basename, dirname, join } from 'path';
+import { basename, delimiter, dirname, join } from 'path';
 
 let _resolvedShell = null;
 let _configuredShell = null;
 // Per-kind cache for resolveShellFor(). 'default' aliases resolveShell()'s
-// singleton; 'bash'/'powershell' get their own memoized slots. ONLY a
-// successful (non-null) resolution is cached — a resolution MISS is
-// deliberately not memoized so the next call re-probes (Git Bash / pwsh may
-// be installed mid-session, and PATH can change for a long-lived host).
+// singleton; 'bash'/'powershell' get their own memoized slots. Misses receive
+// a short TTL so a missing optional shell cannot rescan PATH for every tool
+// call while a long-lived host can still discover a later installation.
 const _resolvedShellByKind = new Map();
+const SHELL_RESOLUTION_MISS_TTL_MS = 30_000;
 
 export function setConfiguredShell(value = '') {
     const next = String(value || '').trim();
@@ -43,30 +42,39 @@ function shellSpec(shell, shellType = shellTypeFor(shell)) {
     return { shell, shellArg: '-c', shellArgs: ['-c'], shellType };
 }
 
-function firstExistingPathFromWhere(commandName) {
-    try {
-        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
-            stdio: ['ignore', 'pipe', 'ignore'],
-            windowsHide: true,
-            timeout: 1000,
-        });
-        if (r.status !== 0 || !r.stdout) return null;
-        const lines = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-        return lines.find(p => existsSync(p)) || null;
-    } catch {
-        return null;
+function allExistingPathsFromPath(commandName) {
+    const rawPath = String(process.env.PATH || '');
+    let cwd = '';
+    try { cwd = process.cwd(); } catch {}
+    const entries = [cwd, ...rawPath.split(delimiter)]
+        .map((entry) => entry.trim().replace(/^"(.*)"$/, '$1'))
+        .filter(Boolean);
+    const seen = new Set();
+    const matches = [];
+    for (const entry of entries) {
+        const candidate = join(entry, commandName);
+        const key = process.platform === 'win32' ? candidate.toLowerCase() : candidate;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (existsSync(candidate)) matches.push(candidate);
     }
+    return matches;
+}
+
+function firstExistingPathFromPath(commandName, excludeRe = null) {
+    return allExistingPathsFromPath(commandName)
+        .find((candidate) => !excludeRe || !excludeRe.test(candidate)) || null;
 }
 
 function resolveWindowsPowerShell() {
-    const pwsh = firstExistingPathFromWhere('pwsh.exe');
+    const pwsh = firstExistingPathFromPath('pwsh.exe');
     if (pwsh) return shellSpec(pwsh, 'powershell');
 
     const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
     const bundled = join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
     if (existsSync(bundled)) return shellSpec(bundled, 'powershell');
 
-    const powershell = firstExistingPathFromWhere('powershell.exe');
+    const powershell = firstExistingPathFromPath('powershell.exe');
     if (powershell) return shellSpec(powershell, 'powershell');
 
     return shellSpec('powershell.exe', 'powershell');
@@ -109,12 +117,12 @@ function _isWindows() {
 //     not Git-for-Windows bash).
 // Returns a posix shellSpec, or null when Git Bash is genuinely not installed.
 function resolveWindowsGitBash() {
-    for (const git of allExistingPathsFromWhere('git.exe')) {
+    for (const git of allExistingPathsFromPath('git.exe')) {
         const bash = probeGitBashFromGitExe(git);
         if (bash) return shellSpec(bash, 'posix');
     }
     // Fallback: a bare `bash.exe` on PATH, but never the System32 WSL launcher.
-    const bash = firstExistingPathFromWhereExcluding('bash.exe', /\\system32\\/i);
+    const bash = firstExistingPathFromPath('bash.exe', /\\system32\\/i);
     if (bash) return shellSpec(bash, 'posix');
     // Final fallback: probe well-known Git-for-Windows install roots on the
     // filesystem directly. PATH-independent and spawn-free, so it still resolves
@@ -164,36 +172,6 @@ function probeGitBashFromGitExe(gitExe) {
     return null;
 }
 
-function allExistingPathsFromWhere(commandName) {
-    try {
-        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
-            stdio: ['ignore', 'pipe', 'ignore'],
-            windowsHide: true,
-            timeout: 1000,
-        });
-        if (r.status !== 0 || !r.stdout) return [];
-        return r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim())
-            .filter(Boolean).filter(p => existsSync(p));
-    } catch {
-        return [];
-    }
-}
-
-function firstExistingPathFromWhereExcluding(commandName, excludeRe) {
-    try {
-        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
-            stdio: ['ignore', 'pipe', 'ignore'],
-            windowsHide: true,
-            timeout: 1000,
-        });
-        if (r.status !== 0 || !r.stdout) return null;
-        const lines = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-        return lines.find(p => existsSync(p) && !excludeRe.test(p)) || null;
-    } catch {
-        return null;
-    }
-}
-
 // Kind-aware shell resolution. kind:
 //
 // Resolve a real bash on macOS/Linux. When 'bash' is explicitly requested we
@@ -204,13 +182,8 @@ function resolvePosixBash() {
     for (const p of ['/bin/bash', '/usr/bin/bash', '/usr/local/bin/bash', '/opt/homebrew/bin/bash']) {
         if (existsSync(p)) return shellSpec(p, 'posix');
     }
-    try {
-        const r = spawnSync('which', ['bash'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 1000 });
-        if (r.status === 0 && r.stdout) {
-            const p = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).find(Boolean);
-            if (p && existsSync(p)) return shellSpec(p, 'posix');
-        }
-    } catch { /* fall through to /bin/sh */ }
+    const fromPath = firstExistingPathFromPath('bash');
+    if (fromPath) return shellSpec(fromPath, 'posix');
     return shellSpec('/bin/sh', 'posix');
 }
 
@@ -220,12 +193,15 @@ function resolvePosixBash() {
 //                 binary (/bin/bash, /usr/bin/bash, or `bash` on PATH), falling back to
 //                 /bin/sh only when no bash exists (dash/ash distros break on bash syntax).
 //  'powershell' → on Windows, resolveShell(); elsewhere pwsh if present, else null.
-// Each kind is memoized independently, but ONLY on success: a resolution miss
-// (null) is not cached, so the caller's clear-error path is re-probed on the
-// next call rather than pinned for the life of the process.
+// Each kind is memoized independently. Successes remain stable for the process;
+// misses expire quickly so installs/PATH changes remain discoverable.
 export function resolveShellFor(kind = 'default') {
     if (kind == null || kind === 'default') return resolveShell();
-    if (_resolvedShellByKind.has(kind)) return _resolvedShellByKind.get(kind);
+    const cached = _resolvedShellByKind.get(kind);
+    if (cached) {
+        if (cached.spec || cached.expiresAt > Date.now()) return cached.spec;
+        _resolvedShellByKind.delete(kind);
+    }
 
     let spec = null;
     if (kind === 'bash') {
@@ -234,21 +210,16 @@ export function resolveShellFor(kind = 'default') {
         if (_isWindows()) {
             spec = resolveShell();
         } else {
-            const pwsh = (() => {
-                try {
-                    const r = spawnSync('which', ['pwsh'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 1000 });
-                    if (r.status !== 0 || !r.stdout) return null;
-                    const p = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).find(Boolean);
-                    return p && existsSync(p) ? p : null;
-                } catch { return null; }
-            })();
+            const pwsh = firstExistingPathFromPath('pwsh');
             spec = pwsh ? shellSpec(pwsh, 'powershell') : null;
         }
     } else {
         spec = resolveShell();
     }
 
-    // Cache positively only — see the _resolvedShellByKind / doc comments above.
-    if (spec) _resolvedShellByKind.set(kind, spec);
+    _resolvedShellByKind.set(kind, {
+        spec,
+        expiresAt: spec ? Number.POSITIVE_INFINITY : Date.now() + SHELL_RESOLUTION_MISS_TTL_MS,
+    });
     return spec;
 }

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.1",
+  "version": "0.1.2",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-darwin-arm64",
-      "sha256": "3fb76a5e3064547b68e7bcab6ce2a855ce615a732157d836cb561c5d7c8d86b6"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-darwin-arm64",
+      "sha256": "e54f09013af2ae057eae89c629237af79caeb248e59c335c64c88fc7b720d662"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-darwin-x64",
-      "sha256": "64eeffc17984a76b0fbf7d85f9d84cb5e1bb949a251053feb260f70481235bb1"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-darwin-x64",
+      "sha256": "d4506109fab2a392157ee016d9dfd2524d74363925004f008795eab3fba3de23"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-linux-arm64",
-      "sha256": "15d5cbb7575b3e0671c6f5fbef3460c5c9353f17968a80faba737fcc15b49c33"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-linux-arm64",
+      "sha256": "ba5f3e52f95c6e0c976115fea9e60c1a1d4534565a15c2da7284ad9c59c1eeb5"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-linux-x64",
-      "sha256": "5079544c09ae2311295cef21978fda3c1c06f93beaaf666cfe1f68971d5b27ae"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-linux-x64",
+      "sha256": "3642d773317a468fe5ba5efc4544ae91a68117b78d577ee2aad37e2639fcc01a"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-win32-x64.exe",
-      "sha256": "acfbcd02b96154f4fb342a44dec1a4808752944c5941bbb7983d84ed64464830"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-win32-x64.exe",
+      "sha256": "3d86870fc6d3ce1151dd97b91fc634fd2755e3f3c74f10809aaea34ae3e2aa02"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/lib/pwsh-standby-pool.mjs

@@ -0,0 +1,286 @@
+'use strict';
+// Warm standby pwsh pool (Windows only). Every one-shot shell call pays the
+// pwsh.exe startup cost (~300ms measured). This pool keeps a few pre-spawned
+// pwsh processes blocked on stdin; execShellCommand adopts one and feeds the
+// command via stdin, cutting call latency roughly in half (measured
+// ~330ms → ~155ms end-to-end).
+//
+// Semantics parity (validated empirically against `pwsh -Command <script>`
+// on exit codes, streams, unicode, multi-line scripts, explicit `exit N`,
+// native failures, Write-Error, parse errors):
+//  - the bootstrap reads RAW stdin bytes and decodes UTF-8 explicitly
+//    ([Console]::In uses the ANSI codepage for redirected stdin — Korean/emoji
+//    would mojibake otherwise);
+//  - the 0/1 exit mapping (`if ($?) { exit 0 } else { exit 1 }`) is APPENDED
+//    INTO the script text so `$?` reflects the user script's LAST statement,
+//    exactly what pwsh -Command does implicitly; explicit `exit N` and
+//    terminating errors bypass it with identical codes;
+//  - cwd is applied in-script (Set-Location + [Environment]::CurrentDirectory)
+//    since the standby was spawned before the call's cwd was known.
+//
+// Adoption rules keep this pool NARROW: win32 + pwsh (never Windows
+// PowerShell 5.1, whose `$?` native semantics differ) + the standard
+// -NoLogo/-NoProfile/-NonInteractive/-Command argv + an env whose signature
+// matches the standby's spawn env. Everything else falls back to the classic
+// cold spawn path unchanged. Kill-switch: MIXDOG_PWSH_STANDBY_POOL=0.
+import { spawn } from 'node:child_process';
+import { basename } from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { killProcessTree, windowsPidHasDescendants } from '../builtin/shell-job-process.mjs';
+
+function _poolTarget() {
+    const n = Math.floor(Number(process.env.MIXDOG_PWSH_STANDBY_POOL));
+    if (Number.isFinite(n) && n >= 0) return Math.min(8, n);
+    return 2;
+}
+const POOL_TARGET = _poolTarget();
+// Only standbys older than this are handed out: a younger one is still paying
+// pwsh startup, so adopting it would just relocate the cold cost. Callers get
+// null (classic spawn) while the pool warms.
+const STANDBY_READY_AGE_MS = 400;
+const EXPECTED_ARGS = Object.freeze(['-NoLogo', '-NoProfile', '-NonInteractive', '-Command']);
+
+// Marker-loop bootstrap: the standby serves MANY commands over its lifetime.
+// Protocol per command (all lines UTF-8 over stdin):
+//   <script lines...>
+//   <<<MIXDOG_RUN_<nonce>>>>
+// The loop resets env + location to the spawn baseline, executes the script
+// with the same `$?`→0/1 exit mapping pwsh -Command applies implicitly, then
+// emits `<<<MIXDOG_DONE_<nonce>:<code>>>>` on stdout and
+// `<<<MIXDOG_DONE_<nonce>>>>` on stderr (both streams provably drained).
+// stdin EOF exits the process with the LAST command's code — that is exactly
+// what background-promotion relies on for its exit-file. A user script that
+// calls `exit N` terminates the whole process with N (identical code to the
+// one-shot path); the caller settles via 'close' and the entry is discarded.
+function _standbyBootScript(nonce) {
+    const runSentinel = `<<<MIXDOG_RUN_${nonce}>>>`;
+    const donePrefix = `<<<MIXDOG_DONE_${nonce}`;
+    return [
+        '$null = & {0}',
+        "[Console]::Out.Write('')",
+        "[Console]::Error.Write('')",
+        '$__sr = New-Object System.IO.StreamReader([Console]::OpenStandardInput(), (New-Object System.Text.UTF8Encoding($false)))',
+        '$__baseEnv = @{}',
+        'Get-ChildItem env: | ForEach-Object { $__baseEnv[$_.Name] = $_.Value }',
+        '$__baseLoc = (Get-Location).ProviderPath',
+        '$__code = 0',
+        'while ($true) {',
+        '  $__buf = New-Object System.Text.StringBuilder',
+        '  while ($true) {',
+        '    $__line = $__sr.ReadLine()',
+        '    if ($null -eq $__line) { exit $__code }',
+        `    if ($__line -eq '${runSentinel}') { break }`,
+        '    [void]$__buf.AppendLine($__line)',
+        '  }',
+        '  foreach ($__n in @(Get-ChildItem env: | ForEach-Object Name)) { if (-not $__baseEnv.ContainsKey($__n)) { Remove-Item ("env:$__n") -ErrorAction SilentlyContinue } }',
+        '  foreach ($__k in $__baseEnv.Keys) { Set-Item ("env:$__k") $__baseEnv[$__k] }',
+        '  Set-Location -LiteralPath $__baseLoc',
+        '  $global:LASTEXITCODE = 0',
+        '  $global:__MIXDOG_RC = 1',
+        '  try {',
+        "    $__sc = [ScriptBlock]::Create($__buf.ToString() + [Environment]::NewLine + 'if ($?) { $global:__MIXDOG_RC = 0 } else { $global:__MIXDOG_RC = 1 }')",
+        '    & $__sc',
+        '  } catch {',
+        '    $global:__MIXDOG_RC = 1',
+        "    [Console]::Error.WriteLine('Exception: ' + $_.Exception.Message)",
+        '  }',
+        '  $__code = $global:__MIXDOG_RC',
+        '  [Console]::Out.Flush()',
+        '  [Console]::Error.Flush()',
+        `  [Console]::Out.WriteLine('${donePrefix}:' + $__code + '>>>')`,
+        `  [Console]::Error.WriteLine('${donePrefix}>>>')`,
+        '}',
+    ].join('\n');
+}
+
+const _idle = [];
+let _envSig = null;
+let _exitHookInstalled = false;
+
+function _envSignature(env) {
+    const h = createHash('sha1');
+    for (const k of Object.keys(env).sort()) {
+        h.update(k); h.update('='); h.update(String(env[k] ?? '')); h.update('\0');
+    }
+    return h.digest('base64');
+}
+
+function _killEntry(entry) {
+    try { entry.child.kill(); } catch { /* already down */ }
+}
+
+function _discardIdle(entry) {
+    const i = _idle.indexOf(entry);
+    if (i !== -1) _idle.splice(i, 1);
+}
+
+function _installExitHook() {
+    if (_exitHookInstalled) return;
+    _exitHookInstalled = true;
+    // Idle standbys block on stdin forever; never leave them behind.
+    process.once('exit', () => {
+        for (const entry of _idle.splice(0)) _killEntry(entry);
+    });
+}
+
+function _spawnStandby(shell, env, sig) {
+    let child;
+    const nonce = randomBytes(8).toString('hex');
+    try {
+        child = spawn(shell, [...EXPECTED_ARGS, _standbyBootScript(nonce)], {
+            env,
+            cwd: process.env.SystemRoot || 'C:\\Windows',
+            windowsHide: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: false,
+        });
+    } catch { return; }
+    const entry = { child, sig, nonce, spawnedAt: Date.now(), taken: false, consumed: false };
+    child.on('error', () => { if (!entry.taken) { _discardIdle(entry); _killEntry(entry); } });
+    child.on('exit', () => { if (!entry.taken) _discardIdle(entry); });
+    // A dead standby's pending stdin write must never crash the daemon.
+    child.stdin?.on?.('error', () => { /* swallow — entry is discarded via exit */ });
+    // Idle standbys must not hold the event loop open (process handle AND
+    // pipe handles each ref it). Re-ref'd on take.
+    try {
+        child.unref();
+        child.stdin?.unref?.();
+        child.stdout?.unref?.();
+        child.stderr?.unref?.();
+    } catch { /* best-effort */ }
+    _idle.push(entry);
+}
+
+function _topUp(shell, env, sig) {
+    while (_idle.length < POOL_TARGET) _spawnStandby(shell, env, sig);
+}
+
+/**
+ * Adopt a warm standby for this call, or return null for the classic spawn
+ * path. On success returns { child, feed(spawnCommand, cwd) }; the caller
+ * wires its stdio/exit handlers FIRST and then calls feed() exactly once.
+ */
+export function takePwshStandby({ shell, shellArgs, env }) {
+    if (process.platform !== 'win32' || POOL_TARGET === 0) return null;
+    const stem = basename(String(shell || '')).toLowerCase();
+    if (stem !== 'pwsh' && stem !== 'pwsh.exe') return null;
+    if (!Array.isArray(shellArgs)
+        || shellArgs.length !== EXPECTED_ARGS.length
+        || shellArgs.some((a, i) => a !== EXPECTED_ARGS[i])) return null;
+    if (!env || typeof env !== 'object') return null;
+    _installExitHook();
+    const sig = _envSignature(env);
+    if (sig !== _envSig) {
+        // Env changed (secrets scrub set, locale, config reload): stale
+        // standbys would run with the old env — drain and respawn.
+        for (const entry of _idle.splice(0)) _killEntry(entry);
+        _envSig = sig;
+    }
+    _topUp(shell, env, sig);
+    const now = Date.now();
+    let entry = null;
+    for (let i = 0; i < _idle.length; i += 1) {
+        const cand = _idle[i];
+        if (now - cand.spawnedAt < STANDBY_READY_AGE_MS) continue;
+        if (cand.child.exitCode !== null || cand.child.signalCode !== null) continue;
+        if (!cand.child.stdin || cand.child.stdin.destroyed) continue;
+        _idle.splice(i, 1);
+        entry = cand;
+        break;
+    }
+    if (!entry) return null;
+    entry.taken = true;
+    entry.consumed = false;
+    try {
+        entry.child.ref();
+        entry.child.stdin?.ref?.();
+        entry.child.stdout?.ref?.();
+        entry.child.stderr?.ref?.();
+    } catch { /* best-effort */ }
+    _topUp(shell, env, sig);
+    return {
+        child: entry.child,
+        nonce: entry.nonce,
+        runSentinel: `<<<MIXDOG_RUN_${entry.nonce}>>>`,
+        doneMarkerPrefix: `<<<MIXDOG_DONE_${entry.nonce}`,
+        run(spawnCommand, cwdForRun) {
+            const esc = String(cwdForRun || '').replace(/'/g, "''");
+            const prelude = esc
+                ? `Set-Location -LiteralPath '${esc}' -ErrorAction Stop\n[Environment]::CurrentDirectory = '${esc}'\n`
+                : '';
+            try {
+                const body = prelude + String(spawnCommand ?? '');
+                entry.child.stdin.write(body.endsWith('\n') ? body : `${body}\n`, 'utf8');
+                entry.child.stdin.write(`<<<MIXDOG_RUN_${entry.nonce}>>>\n`, 'utf8');
+                return true;
+            } catch {
+                // Feed failed (child died in the take→run window): kill so the
+                // caller's close handler settles with an error result.
+                _killEntry(entry);
+                return false;
+            }
+        },
+        // Background-promotion handoff: after the in-flight command completes,
+        // the loop reads EOF and exits with that command's code — the adopted
+        // job's close-wired exit file then records the REAL command exit.
+        endStdin() {
+            entry.consumed = true;
+            try { entry.child.stdin.end(); } catch { /* already gone */ }
+        },
+        // Post-command recycle: return the standby to the pool ONLY when the
+        // command left no descendant processes attached to its stdio (a live
+        // grandchild would pollute the NEXT command's capture). Dirty, dead,
+        // env-stale, or surplus standbys are tree-killed instead. Runs off the
+        // result path; the caller releases its admission lease afterwards.
+        async recycle() {
+            if (entry.consumed) return false;
+            entry.consumed = true;
+            const c = entry.child;
+            const alive = () => c.exitCode === null && c.signalCode === null;
+            let dirty = true;
+            if (alive() && c.stdin && !c.stdin.destroyed) {
+                try { dirty = await windowsPidHasDescendants(c.pid); } catch { dirty = true; }
+            }
+            if (dirty || !alive() || !c.stdin || c.stdin.destroyed
+                || _idle.length >= POOL_TARGET || _envSig !== entry.sig) {
+                try { killProcessTree(c.pid, 'SIGKILL'); } catch { /* already down */ }
+                _killEntry(entry);
+                return false;
+            }
+            entry.taken = false;
+            entry.consumed = false;
+            entry.spawnedAt = Date.now() - STANDBY_READY_AGE_MS;
+            try {
+                c.unref();
+                c.stdin?.unref?.();
+                c.stdout?.unref?.();
+                c.stderr?.unref?.();
+            } catch { /* best-effort */ }
+            _idle.push(entry);
+            return true;
+        },
+    };
+}
+
+/**
+ * Boot-time warmup: spawn the standby processes NOW (same gates as take) so a
+ * session's first shell call finds a warm pool instead of paying the pwsh
+ * startup cost. Best-effort; returns true when standbys were ensured.
+ */
+export function prewarmPwshStandbyPool({ shell, shellArgs, env }) {
+    if (process.platform !== 'win32' || POOL_TARGET === 0) return false;
+    const stem = basename(String(shell || '')).toLowerCase();
+    if (stem !== 'pwsh' && stem !== 'pwsh.exe') return false;
+    if (!Array.isArray(shellArgs)
+        || shellArgs.length !== EXPECTED_ARGS.length
+        || shellArgs.some((a, i) => a !== EXPECTED_ARGS[i])) return false;
+    if (!env || typeof env !== 'object') return false;
+    _installExitHook();
+    const sig = _envSignature(env);
+    if (sig !== _envSig) {
+        for (const entry of _idle.splice(0)) _killEntry(entry);
+        _envSig = sig;
+    }
+    _topUp(shell, env, sig);
+    return true;
+}

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

@@ -1,26 +1,26 @@
 {
-  "version": "0.7.20",
+  "version": "0.7.21",
   "_comment": "Rewritten by .github/workflows/patch-release.yml on each tagged release. assets maps platformKey (process.platform-process.arch, e.g. win32-x64, linux-x64, darwin-arm64) to { url, sha256 } of the mixdog-patch binary on the GitHub release. A local cargo build under native/mixdog-patch/target/release always takes precedence; otherwise the binary is fetched per this manifest into the data dir (apply is native-only — no JS apply engine).",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.20/mixdog-patch-darwin-arm64",
-      "sha256": "12b9b3ad3365fcde21c83c1b42236f6bd70dbe411d79e5c0f7c3c5743f1a3185"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.21/mixdog-patch-darwin-arm64",
+      "sha256": "f52db5c65ffdc28ace93a6dd54d7d1c8e76f3daba45a74e63676513fcee4b51b"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.20/mixdog-patch-darwin-x64",
-      "sha256": "ff5de6da5fec3abbf617c0c3b1ead8e724d4cb0e9948277253889c83bc27a570"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.21/mixdog-patch-darwin-x64",
+      "sha256": "024bacaaead16a368fa4a2a148f66f3892ee03be78803c40dda9acd59f3dd2c1"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.20/mixdog-patch-linux-arm64",
-      "sha256": "76d7cf54df7face32fb20862425ce25ad44e9800440132dea3f0ad387c92f07e"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.21/mixdog-patch-linux-arm64",
+      "sha256": "c197931e005fb89211b60b66008bc0c3b42200393483e0ae4a251e2111a06d44"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.20/mixdog-patch-linux-x64",
-      "sha256": "43f6610beadf25eca752a09775fcb8858818ad2d9f7b8cf6a00deaa47571f3f0"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.21/mixdog-patch-linux-x64",
+      "sha256": "8d958f9315ec82a17fa2e21560630f66a4e55a8a56ad92d69ba9f3f5ff61c15c"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.20/mixdog-patch-win32-x64.exe",
-      "sha256": "4d5d2242f9662aeb968c24df571a498008d9c504fd31214fe9dac31aac669fdd"
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.21/mixdog-patch-win32-x64.exe",
+      "sha256": "cc927c7bc6f09ecae591c058d0053cd5bc65ee17c56c9bce6871487be1d2baa2"
     }
   }
 }