mixdog 0.9.85 → 0.9.86

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"
     }
   }
 }

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

@@ -46,6 +46,7 @@ import {
   extractPowerShellCommandInner,
 } from './shell-powershell.mjs';
 import { spawnShellWithRetry as _spawnShellWithRetry } from './lib/shell-spawn-retry.mjs';
+import { takePwshStandby } from './lib/pwsh-standby-pool.mjs';
 
 export {
   _maybeEncodePowerShellCommand,
@@ -312,6 +313,11 @@ export function execShellCommand({
     const _isBackground = /(^|[^&|])&$/.test(_trimmed);
 
     let child;
+    let _standby = null;
+    let _viaMarker = false;
+    let _standbyDetach = null;
+    let _markerFilters = null;
+    let _onChildErrorRef = null;
     try {
       resourceLease = await _acquireShellLeaseBounded(admission, {
         abortSignal,
@@ -339,6 +345,25 @@ export function execShellCommand({
       const argv = Array.isArray(shellArgs) && shellArgs.length > 0
         ? [...shellArgs, _spawnCommand]
         : [shellArg, _spawnCommand];
+      const _onChildError = (err) => {
+        spawnError = spawnError || err;
+        failurePhase = 'tool';
+        failureReason = 'spawn failed';
+        if (settle) settle(1, null);
+        else pendingChildError = pendingChildError || err;
+      };
+      _onChildErrorRef = _onChildError;
+      // Warm standby adoption (Windows/pwsh only, see pwsh-standby-pool.mjs):
+      // a pre-spawned pwsh blocked on stdin replaces the cold spawn. The
+      // command is fed via stdin AFTER the stdio/exit wiring below, so no
+      // output can be produced before the capture handlers are attached.
+      // Standby children always use pipe capture — identical to the win32
+      // default (SHELL_DIRECT_CAPTURE is false on win32).
+      _standby = takePwshStandby({ shell, shellArgs, env });
+      if (_standby) {
+        child = _standby.child;
+        child.on('error', _onChildError);
+      } else {
       // Direct capture (CC file-mode parity): the child writes stdout/stderr
       // into the spill files via inherited fds. No parent pipes exist, so
       // 'close' fires with 'exit' and grandchildren cannot hold the capture
@@ -371,13 +396,8 @@ export function execShellCommand({
         },
       });
       child = spawned.child;
-      spawned.adoptErrorHandler((err) => {
-        spawnError = spawnError || err;
-        failurePhase = 'tool';
-        failureReason = 'spawn failed';
-        if (settle) settle(1, null);
-        else pendingChildError = pendingChildError || err;
-      });
+      spawned.adoptErrorHandler(_onChildError);
+      }
       startChildGuardian({
         childPid: child.pid,
         childGroupPid: child.pid,
@@ -385,7 +405,12 @@ export function execShellCommand({
       });
       // Windows has no process-group handle. Begin observing while the owned
       // root still exists so descendants can be proven before root exit.
-      releaseResourceLeaseWhenTreeQuiescent(child.pid, { waitForRootExit: true });
+      // Standby children skip the eager tracker: their root stays ALIVE across
+      // commands (waitForRootExit could never confirm and its CIM polling
+      // would run for the standby's whole lifetime). Marker settle releases
+      // the lease through the recycle path instead; kill/exit fallbacks below
+      // create the tracker lazily once the root is really gone.
+      if (!_standby) releaseResourceLeaseWhenTreeQuiescent(child.pid, { waitForRootExit: true });
     } catch (err) {
       const cleanupError = await releaseResourceLease();
       const spawnText = String((err && err.message) || err);
@@ -418,15 +443,77 @@ export function execShellCommand({
     }
 
     // Pipe-capture wiring only; direct mode has no parent-side streams.
+    // Standby children speak the marker protocol: per-command completion
+    // markers on BOTH streams are stripped from the capture and drive settle()
+    // (the process stays alive for the next command), while kill/exit paths
+    // still settle through 'close' as before.
+    let _stdoutData = (chunk) => { taskOutput.writeStdout(chunk); };
+    let _stderrData = (chunk) => taskOutput.writeStderr(chunk);
+    if (_standby) {
+      const donePrefix = _standby.doneMarkerPrefix;
+      const _mk = { outDone: false, errDone: false, code: 1 };
+      const tryComplete = () => {
+        if (!_mk.outDone || !_mk.errDone) return;
+        if (settled || autoBackgrounded || killed) return;
+        // Both streams delivered their marker — everything the command wrote
+        // is already in the capture. Detach BEFORE settle so late output from
+        // an undiscovered descendant can never pollute this task, then settle
+        // through the marker path (recycle + direct lease release).
+        _standbyDetach?.();
+        _viaMarker = true;
+        settle(_mk.code, null);
+      };
+      const makeFilter = (write, onMarkerLine) => {
+        let tail = '';
+        return {
+          data: (chunk) => {
+            tail += chunk;
+            let idx;
+            let out = '';
+            while ((idx = tail.indexOf('\n')) !== -1) {
+              const line = tail.slice(0, idx + 1);
+              tail = tail.slice(idx + 1);
+              if (line.startsWith(donePrefix)) { onMarkerLine(line); continue; }
+              out += line;
+            }
+            if (out) write(out);
+            // A marker always ends with a newline, so only a pathological
+            // marker-free run can grow the tail; spill it but keep enough to
+            // recognize a marker split across chunks.
+            if (tail.length > 65536) { write(tail.slice(0, -256)); tail = tail.slice(-256); }
+          },
+          flush: () => { if (tail) { write(tail); tail = ''; } },
+        };
+      };
+      const outFilter = makeFilter((s) => taskOutput.writeStdout(s), (line) => {
+        const m = /^:(-?\d+)>>>/.exec(line.slice(donePrefix.length));
+        _mk.code = m ? Number(m[1]) : 1;
+        _mk.outDone = true;
+        tryComplete();
+      });
+      const errFilter = makeFilter((s) => taskOutput.writeStderr(s), () => {
+        _mk.errDone = true;
+        tryComplete();
+      });
+      _markerFilters = [outFilter, errFilter];
+      _stdoutData = outFilter.data;
+      _stderrData = errFilter.data;
+    }
     if (child.stdout) {
       child.stdout.setEncoding('utf-8');
-      child.stdout.on('data', (chunk) => {
-        taskOutput.writeStdout(chunk);
-      });
+      child.stdout.on('data', _stdoutData);
     }
     if (child.stderr) {
       child.stderr.setEncoding('utf-8');
-      child.stderr.on('data', (chunk) => taskOutput.writeStderr(chunk));
+      child.stderr.on('data', _stderrData);
+    }
+
+    // Standby path: the capture handlers are attached — release the command
+    // into the waiting pwsh now. Skipped when a pre-fired abort already
+    // tree-killed the child (its close still settles the call).
+    if (_standby && !killed) {
+      const _spawnCommandForStandby = _maybeEncodePowerShellCommand(command);
+      _standby.run(_spawnCommandForStandby, cwd);
     }
 
     // If the spill writer hits an I/O failure (full disk, EBADF after
@@ -456,6 +543,11 @@ export function execShellCommand({
         autoBgTimer = null;
       }
       detachAbortHandler();
+      // Marker-free paths (kill/exit) may hold a partial last line in the
+      // standby stream filters — flush it so the capture keeps the tail.
+      if (_markerFilters) {
+        for (const f of _markerFilters) { try { f.flush(); } catch { /* best-effort */ } }
+      }
       // getStdout/getStderr can throw on a spilled-file read failure (EBADF
       // after unlink race, EACCES). Without this catch the rejection bubbles
       // up and leaves the outer settle promise unresolved, hanging the call.
@@ -480,12 +572,34 @@ export function execShellCommand({
       } else {
         taskOutput.closeFds();
       }
+      if (_viaMarker && _standby) {
+        // Marker-settled standby: the root pwsh is ALIVE by design, so the
+        // waitForRootExit tracker could never confirm. recycle() probes for
+        // leftover descendants off the result path (returns the standby to the
+        // pool when clean, tree-kills it otherwise) and the lease frees after.
+        const lease = resourceLease;
+        resourceLease = null;
+        void _standby.recycle()
+          .catch(() => false)
+          .then(() => { try { return Promise.resolve(lease?.release()).catch(() => {}); } catch { return null; } });
+      } else {
       const leaseSettlement = resourceLeaseSettlement
         || releaseResourceLeaseWhenTreeQuiescent(child.pid);
       leaseSettlement.tracker?.rootExited?.();
-      await leaseSettlement.tracker?.afterRootExitCheck?.();
-      if (!leaseSettlement.pending) await leaseSettlement.promise;
-      else _armLeaseLingerCap(() => leaseSettlement.lease, taskId);
+      // Decoupled lease settlement: the tool RESULT resolves immediately —
+      // the output is fully captured above and nothing in ExecResult depends
+      // on admission accounting. The quiescence proof (a Windows CIM process
+      // snapshot costing ~200ms per call) and the lease release continue in
+      // the background: exactly-once release is owned by the tracker/lease,
+      // and the linger cap still bounds a stuck descendant tree.
+      void (async () => {
+        try {
+          await leaseSettlement.tracker?.afterRootExitCheck?.();
+          if (!leaseSettlement.pending) await leaseSettlement.promise;
+          else _armLeaseLingerCap(() => leaseSettlement.lease, taskId);
+        } catch { /* background release must never throw */ }
+      })();
+      }
       resolveResult(
         new ExecResult({
           stdout,
@@ -513,14 +627,15 @@ export function execShellCommand({
     // bytes; settling there can lose the tail of the output. 'close' fires
     // after stdio is fully drained, so getStdout()/getStderr() see the
     // complete capture.
-    child.once('close', (code, signal) => settle(code, signal));
+    const _onChildClose = (code, signal) => settle(code, signal);
+    child.once('close', _onChildClose);
     if (pendingChildError) settle(1, null);
     // 'close' only fires after stdio drains; a forked grandchild that
     // inherited stdout/stderr fds can hold them open past direct-child
     // exit and stall settle() until timeoutMs. 'exit' fires on direct
     // child termination regardless — give 'close' a 2 s grace then
     // settle anyway.
-    child.once('exit', (code, signal) => {
+    const _onChildExit = (code, signal) => {
       if (_isBackground) {
         setImmediate(() => settle(code == null ? 1 : code, signal));
         return;
@@ -531,7 +646,21 @@ export function execShellCommand({
         settle(code == null ? 1 : code, signal);
       }, 2000);
       if (grace.unref) grace.unref();
-    });
+    };
+    child.once('exit', _onChildExit);
+    // Standby recycle prerequisite: THIS command's listeners must come off the
+    // long-lived child before it can serve another command (otherwise every
+    // reuse would stack another close/exit/data listener and stale handlers
+    // would keep writing into this task's finished capture).
+    _standbyDetach = () => {
+      try { child.stdout?.removeListener('data', _stdoutData); } catch { /* best-effort */ }
+      try { child.stderr?.removeListener('data', _stderrData); } catch { /* best-effort */ }
+      try { child.removeListener('close', _onChildClose); } catch { /* best-effort */ }
+      try { child.removeListener('exit', _onChildExit); } catch { /* best-effort */ }
+      if (_onChildErrorRef) {
+        try { child.removeListener('error', _onChildErrorRef); } catch { /* best-effort */ }
+      }
+    };
 
     // Auto-background transition (CC startBackgrounding analogue). Two triggers
     // resolve the call immediately with a 'backgrounded' result while the
@@ -552,6 +681,11 @@ export function execShellCommand({
       if (settled || autoBackgrounded || killed || timedOut) return;
       if (child.exitCode != null || child.signalCode != null) return;
       autoBackgrounded = true;
+      // Standby handoff: stop feeding this process. Once the in-flight
+      // command completes, the marker loop reads stdin EOF and exits with
+      // that command's code — the adopted job's close-wired exit file then
+      // records the real command exit, and the standby is never reused.
+      if (_standby) { try { _standby.endStdin(); } catch { /* best-effort */ } }
       // The foreground capture is over; stop the local watchdogs/timers so
       // they cannot treeKill the now-adopted child.
       if (timer) { clearTimeout(timer); timer = null; }