@openclaw/crabline 0.1.11 → 0.1.13

package/dist/src/providers/builtin/script.js

@@ -1,10 +1,512 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn, } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import { z } from "zod";
 import { CrablineError, ensureErrorMessage } from "../../core/errors.js";
 const MAX_SCRIPT_OUTPUT_BYTES = 1024 * 1024;
 const SCRIPT_WAIT_EXIT_GRACE_MS = 250;
-const WINDOWS_TERMINATION_TIMEOUT_MS = 5_000;
+const CHILD_CLOSE_TIMEOUT_MS = 1_000;
+const WINDOWS_TERMINATION_COMMAND_TIMEOUT_MS = 2_500;
+const WINDOWS_JOB_COMMAND_ENV = "CRABLINE_INTERNAL_SCRIPT_JOB_COMMAND";
+const WINDOWS_JOB_SHELL_ENV = "CRABLINE_INTERNAL_SCRIPT_JOB_SHELL";
+const WINDOWS_JOB_HELPER_SOURCE_ENV = "CRABLINE_INTERNAL_SCRIPT_JOB_HELPER_SOURCE";
+const WINDOWS_JOB_HELPER_OUTPUT_ENV = "CRABLINE_INTERNAL_SCRIPT_JOB_HELPER_OUTPUT";
+const WINDOWS_JOB_HELPER_SOURCE = [
+    "using System;",
+    "using System.ComponentModel;",
+    "using System.Runtime.InteropServices;",
+    "using System.Text;",
+    "public static class CrablineScriptJob{",
+    "private const uint CreateSuspended=0x00000004;",
+    "private const uint ExtendedStartupInfoPresent=0x00080000;",
+    "private const uint Infinite=0xffffffff;",
+    "private const uint JobObjectLimitKillOnJobClose=0x00002000;",
+    "private const int ProcThreadAttributeJobList=0x0002000d;",
+    "private const uint StartfUseStdHandles=0x00000100;",
+    "private const uint DuplicateSameAccess=0x00000002;",
+    "private const uint ResumeThreadFailed=0xffffffff;",
+    "private const int JobObjectExtendedLimitInformationClass=9;",
+    "private const int StdInputHandle=-10;",
+    "private const int StdOutputHandle=-11;",
+    "private const int StdErrorHandle=-12;",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct ProcessInformation{",
+    "public IntPtr Process;",
+    "public IntPtr Thread;",
+    "public uint ProcessId;",
+    "public uint ThreadId;",
+    "}",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct StartupInfo{",
+    "public int Size;",
+    "public IntPtr Reserved;",
+    "public IntPtr Desktop;",
+    "public IntPtr Title;",
+    "public int X;",
+    "public int Y;",
+    "public int XSize;",
+    "public int YSize;",
+    "public int XCountChars;",
+    "public int YCountChars;",
+    "public int FillAttribute;",
+    "public uint Flags;",
+    "public short ShowWindow;",
+    "public short Reserved2Size;",
+    "public IntPtr Reserved2;",
+    "public IntPtr StandardInput;",
+    "public IntPtr StandardOutput;",
+    "public IntPtr StandardError;",
+    "}",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct StartupInfoEx{",
+    "public StartupInfo StartupInfo;",
+    "public IntPtr AttributeList;",
+    "}",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct JobObjectBasicLimitInformation{",
+    "public long PerProcessUserTimeLimit;",
+    "public long PerJobUserTimeLimit;",
+    "public uint LimitFlags;",
+    "public UIntPtr MinimumWorkingSetSize;",
+    "public UIntPtr MaximumWorkingSetSize;",
+    "public uint ActiveProcessLimit;",
+    "public IntPtr Affinity;",
+    "public uint PriorityClass;",
+    "public uint SchedulingClass;",
+    "}",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct IoCounters{",
+    "public ulong ReadOperationCount;",
+    "public ulong WriteOperationCount;",
+    "public ulong OtherOperationCount;",
+    "public ulong ReadTransferCount;",
+    "public ulong WriteTransferCount;",
+    "public ulong OtherTransferCount;",
+    "}",
+    "[StructLayout(LayoutKind.Sequential)]",
+    "private struct JobObjectExtendedLimitInformation{",
+    "public JobObjectBasicLimitInformation BasicLimitInformation;",
+    "public IoCounters IoInfo;",
+    "public UIntPtr ProcessMemoryLimit;",
+    "public UIntPtr JobMemoryLimit;",
+    "public UIntPtr PeakProcessMemoryUsed;",
+    "public UIntPtr PeakJobMemoryUsed;",
+    "}",
+    '[DllImport("kernel32.dll",SetLastError=true,CharSet=CharSet.Unicode)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool CreateProcess(string applicationName,StringBuilder commandLine,IntPtr processAttributes,IntPtr threadAttributes,bool inheritHandles,uint creationFlags,IntPtr environment,string currentDirectory,ref StartupInfoEx startupInfo,out ProcessInformation processInformation);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern IntPtr CreateJobObject(IntPtr jobAttributes,string name);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool SetInformationJobObject(IntPtr job,int informationClass,ref JobObjectExtendedLimitInformation information,uint informationLength);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool InitializeProcThreadAttributeList(IntPtr attributeList,int attributeCount,int flags,ref IntPtr size);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool UpdateProcThreadAttribute(IntPtr attributeList,uint flags,IntPtr attribute,IntPtr value,IntPtr size,IntPtr previousValue,IntPtr returnSize);",
+    '[DllImport("kernel32.dll")]',
+    "private static extern void DeleteProcThreadAttributeList(IntPtr attributeList);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool DuplicateHandle(IntPtr sourceProcess,IntPtr sourceHandle,IntPtr targetProcess,out IntPtr targetHandle,uint desiredAccess,bool inheritHandle,uint options);",
+    '[DllImport("kernel32.dll")]',
+    "private static extern IntPtr GetCurrentProcess();",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern IntPtr GetStdHandle(int standardHandle);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern uint ResumeThread(IntPtr thread);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern uint WaitForSingleObject(IntPtr handle,uint milliseconds);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool GetExitCodeProcess(IntPtr process,out uint exitCode);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool TerminateProcess(IntPtr process,uint exitCode);",
+    '[DllImport("kernel32.dll")]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool CloseHandle(IntPtr handle);",
+    "private static void ThrowLastError(string operation){throw new Win32Exception(Marshal.GetLastWin32Error(),operation);}",
+    "private static IntPtr DuplicateStandardHandle(int standardHandle){",
+    "IntPtr source=GetStdHandle(standardHandle);",
+    "IntPtr duplicate=IntPtr.Zero;",
+    "IntPtr process=GetCurrentProcess();",
+    'if(source==IntPtr.Zero||source==new IntPtr(-1)||!DuplicateHandle(process,source,process,out duplicate,0,true,DuplicateSameAccess)){ThrowLastError("Could not duplicate a script standard handle.");}',
+    "return duplicate;",
+    "}",
+    "private static int Run(string applicationName,string commandLine){",
+    "IntPtr job=IntPtr.Zero;",
+    "IntPtr attributeList=IntPtr.Zero;",
+    "IntPtr jobList=IntPtr.Zero;",
+    "IntPtr standardInput=IntPtr.Zero;",
+    "IntPtr standardOutput=IntPtr.Zero;",
+    "IntPtr standardError=IntPtr.Zero;",
+    "ProcessInformation processInformation=new ProcessInformation();",
+    "bool processCreated=false;",
+    "try{",
+    "job=CreateJobObject(IntPtr.Zero,null);",
+    'if(job==IntPtr.Zero){ThrowLastError("Could not create the script job object.");}',
+    "JobObjectExtendedLimitInformation limits=new JobObjectExtendedLimitInformation();",
+    "limits.BasicLimitInformation.LimitFlags=JobObjectLimitKillOnJobClose;",
+    'if(!SetInformationJobObject(job,JobObjectExtendedLimitInformationClass,ref limits,(uint)Marshal.SizeOf(typeof(JobObjectExtendedLimitInformation)))){ThrowLastError("Could not configure the script job object.");}',
+    "IntPtr attributeListSize=IntPtr.Zero;",
+    "InitializeProcThreadAttributeList(IntPtr.Zero,1,0,ref attributeListSize);",
+    "attributeList=Marshal.AllocHGlobal(attributeListSize);",
+    'if(!InitializeProcThreadAttributeList(attributeList,1,0,ref attributeListSize)){ThrowLastError("Could not initialize the script job attribute list.");}',
+    "jobList=Marshal.AllocHGlobal(IntPtr.Size);",
+    "Marshal.WriteIntPtr(jobList,job);",
+    'if(!UpdateProcThreadAttribute(attributeList,0,new IntPtr(ProcThreadAttributeJobList),jobList,new IntPtr(IntPtr.Size),IntPtr.Zero,IntPtr.Zero)){ThrowLastError("Could not bind the script process to its job object.");}',
+    "standardInput=DuplicateStandardHandle(StdInputHandle);",
+    "standardOutput=DuplicateStandardHandle(StdOutputHandle);",
+    "standardError=DuplicateStandardHandle(StdErrorHandle);",
+    "StartupInfoEx startupInfo=new StartupInfoEx();",
+    "startupInfo.StartupInfo.Size=Marshal.SizeOf(typeof(StartupInfoEx));",
+    "startupInfo.StartupInfo.Flags=StartfUseStdHandles;",
+    "startupInfo.StartupInfo.StandardInput=standardInput;",
+    "startupInfo.StartupInfo.StandardOutput=standardOutput;",
+    "startupInfo.StartupInfo.StandardError=standardError;",
+    "startupInfo.AttributeList=attributeList;",
+    'if(!CreateProcess(applicationName,new StringBuilder(commandLine),IntPtr.Zero,IntPtr.Zero,true,CreateSuspended|ExtendedStartupInfoPresent,IntPtr.Zero,Environment.CurrentDirectory,ref startupInfo,out processInformation)){ThrowLastError("Could not start the script command.");}',
+    "processCreated=true;",
+    'if(ResumeThread(processInformation.Thread)==ResumeThreadFailed){ThrowLastError("Could not resume the script command.");}',
+    'if(WaitForSingleObject(processInformation.Process,Infinite)==Infinite){ThrowLastError("Could not wait for the script command.");}',
+    "uint exitCode;",
+    'if(!GetExitCodeProcess(processInformation.Process,out exitCode)){ThrowLastError("Could not read the script exit code.");}',
+    "return unchecked((int)exitCode);",
+    "}finally{",
+    "if(processCreated&&processInformation.Process!=IntPtr.Zero){TerminateProcess(processInformation.Process,1);}",
+    "if(processInformation.Thread!=IntPtr.Zero){CloseHandle(processInformation.Thread);}",
+    "if(processInformation.Process!=IntPtr.Zero){CloseHandle(processInformation.Process);}",
+    "if(standardInput!=IntPtr.Zero){CloseHandle(standardInput);}",
+    "if(standardOutput!=IntPtr.Zero){CloseHandle(standardOutput);}",
+    "if(standardError!=IntPtr.Zero){CloseHandle(standardError);}",
+    "if(attributeList!=IntPtr.Zero){DeleteProcThreadAttributeList(attributeList);Marshal.FreeHGlobal(attributeList);}",
+    "if(jobList!=IntPtr.Zero){Marshal.FreeHGlobal(jobList);}",
+    "if(job!=IntPtr.Zero){CloseHandle(job);}",
+    "}",
+    "}",
+    "public static int Main(){",
+    "try{",
+    `string shellValue=Environment.GetEnvironmentVariable("${WINDOWS_JOB_SHELL_ENV}");`,
+    `string commandValue=Environment.GetEnvironmentVariable("${WINDOWS_JOB_COMMAND_ENV}");`,
+    `Environment.SetEnvironmentVariable("${WINDOWS_JOB_SHELL_ENV}",null);`,
+    `Environment.SetEnvironmentVariable("${WINDOWS_JOB_COMMAND_ENV}",null);`,
+    'if(String.IsNullOrEmpty(shellValue)||String.IsNullOrEmpty(commandValue)){throw new InvalidOperationException("Missing script job configuration.");}',
+    "string shell=Encoding.UTF8.GetString(Convert.FromBase64String(shellValue));",
+    "string commandLine=Encoding.UTF8.GetString(Convert.FromBase64String(commandValue));",
+    "return Run(shell,commandLine);",
+    "}catch(Exception error){Console.Error.WriteLine(error.Message);return 1;}",
+    "}",
+    "}",
+].join("");
+const WINDOWS_PROCESS_TERMINATOR_SOURCE = [
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public static class CrablineProcessTerminator{",
+    "private const uint ProcessTerminate=0x0001;",
+    "private const uint ProcessQueryLimitedInformation=0x1000;",
+    "private const uint Synchronize=0x00100000;",
+    "private const uint WaitObject0=0;",
+    "private const uint WaitTimeout=258;",
+    "private const int ErrorInvalidParameter=87;",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern IntPtr OpenProcess(uint access,bool inheritHandle,int processId);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool GetProcessTimes(IntPtr process,out long creationTime,out long exitTime,out long kernelTime,out long userTime);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool TerminateProcess(IntPtr process,uint exitCode);",
+    '[DllImport("kernel32.dll",SetLastError=true)]',
+    "private static extern uint WaitForSingleObject(IntPtr handle,uint milliseconds);",
+    '[DllImport("kernel32.dll")]',
+    "[return:MarshalAs(UnmanagedType.Bool)]",
+    "private static extern bool CloseHandle(IntPtr handle);",
+    "public static bool TerminateVerified(int processId,long expectedCreationTime){",
+    "IntPtr handle=OpenProcess(ProcessTerminate|ProcessQueryLimitedInformation|Synchronize,false,processId);",
+    "if(handle==IntPtr.Zero){return Marshal.GetLastWin32Error()==ErrorInvalidParameter;}",
+    "try{",
+    "long creationTime,exitTime,kernelTime,userTime;",
+    "if(!GetProcessTimes(handle,out creationTime,out exitTime,out kernelTime,out userTime)){return false;}",
+    "if(creationTime/10!=expectedCreationTime/10){return true;}",
+    "uint status=WaitForSingleObject(handle,0);",
+    "if(status==WaitObject0){return true;}",
+    "if(status!=WaitTimeout){return false;}",
+    "if(!TerminateProcess(handle,1)){return WaitForSingleObject(handle,0)==WaitObject0;}",
+    "return WaitForSingleObject(handle,1000)==WaitObject0;",
+    "}finally{CloseHandle(handle);}",
+    "}",
+    "}",
+].join("");
+let windowsJobHelperPath;
+let windowsJobHelperBootstrap;
+function removeWindowsJobHelper(directory) {
+    try {
+        rmSync(directory, { force: true, recursive: true });
+    }
+    catch {
+        // The helper may still be exiting during process shutdown.
+    }
+}
+function runWindowsJobHelperCommand(executable, args, options, signal) {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? new Error("Windows script helper bootstrap aborted."));
+    }
+    return new Promise((resolve, reject) => {
+        const startedAtMs = Date.now();
+        let child;
+        let settled = false;
+        let aborting = false;
+        const finish = (error) => {
+            if (settled || aborting) {
+                return;
+            }
+            settled = true;
+            signal.removeEventListener("abort", abort);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const abort = () => {
+            if (settled || aborting) {
+                return;
+            }
+            aborting = true;
+            signal.removeEventListener("abort", abort);
+            void (async () => {
+                try {
+                    await terminateChild(child, startedAtMs, observedAtMs);
+                }
+                catch {
+                    // The command still needs to be drained before returning the original abort.
+                }
+                await waitForChildClose(childClosed);
+                settled = true;
+                reject(signal.reason ?? new Error("Windows script helper bootstrap aborted."));
+            })();
+        };
+        try {
+            child = execFile(executable, args, options, (error) => finish(error ?? undefined));
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const observedAtMs = Date.now();
+        const childClosed = new Promise((resolveClose) => {
+            child.once("close", (code, closeSignal) => resolveClose({ code, signal: closeSignal }));
+        });
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted) {
+            abort();
+        }
+    });
+}
+async function createWindowsJobHelper(signal) {
+    if (windowsJobHelperPath !== undefined) {
+        return windowsJobHelperPath;
+    }
+    let directory;
+    try {
+        directory = mkdtempSync(path.join(tmpdir(), "crabline-script-job-"));
+    }
+    catch (error) {
+        throw new Error("Could not create the Windows script Job Object helper directory.", {
+            cause: error,
+        });
+    }
+    const helperPath = path.join(directory, "crabline-script-job.exe");
+    try {
+        await runWindowsJobHelperCommand("powershell.exe", [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            `Add-Type -TypeDefinition $env:${WINDOWS_JOB_HELPER_SOURCE_ENV} -Language CSharp -OutputAssembly $env:${WINDOWS_JOB_HELPER_OUTPUT_ENV} -OutputType ConsoleApplication`,
+        ], {
+            env: {
+                ...process.env,
+                [WINDOWS_JOB_HELPER_OUTPUT_ENV]: helperPath,
+                [WINDOWS_JOB_HELPER_SOURCE_ENV]: WINDOWS_JOB_HELPER_SOURCE,
+            },
+            timeout: 15_000,
+            windowsHide: true,
+        }, signal);
+        const probeCommand = windowsShellCommand("exit 0");
+        await runWindowsJobHelperCommand(helperPath, [], {
+            env: {
+                ...process.env,
+                [WINDOWS_JOB_COMMAND_ENV]: Buffer.from(probeCommand.commandLine).toString("base64"),
+                [WINDOWS_JOB_SHELL_ENV]: Buffer.from(probeCommand.shell).toString("base64"),
+            },
+            timeout: 5_000,
+            windowsHide: true,
+        }, signal);
+    }
+    catch (error) {
+        removeWindowsJobHelper(directory);
+        throw new Error("Could not initialize the Windows script Job Object helper.", {
+            cause: error,
+        });
+    }
+    windowsJobHelperPath = helperPath;
+    process.once("exit", () => removeWindowsJobHelper(directory));
+    return helperPath;
+}
+function releaseWindowsJobHelperWaiter(bootstrap, reason) {
+    bootstrap.waiters -= 1;
+    if (bootstrap.waiters !== 0 ||
+        windowsJobHelperBootstrap !== bootstrap ||
+        windowsJobHelperPath !== undefined) {
+        return false;
+    }
+    windowsJobHelperBootstrap = undefined;
+    bootstrap.controller.abort(reason ?? new Error("Windows script helper bootstrap has no active waiters."));
+    return true;
+}
+function ensureWindowsJobHelper(signal) {
+    if (windowsJobHelperPath !== undefined) {
+        return Promise.resolve(windowsJobHelperPath);
+    }
+    if (signal?.aborted) {
+        return Promise.reject(signal.reason ?? new Error("Script command aborted."));
+    }
+    let bootstrap = windowsJobHelperBootstrap;
+    if (!bootstrap) {
+        const controller = new AbortController();
+        bootstrap = {
+            controller,
+            promise: Promise.resolve(""),
+            waiters: 0,
+        };
+        bootstrap.promise = createWindowsJobHelper(controller.signal).finally(() => {
+            if (windowsJobHelperBootstrap === bootstrap) {
+                windowsJobHelperBootstrap = undefined;
+            }
+        });
+        windowsJobHelperBootstrap = bootstrap;
+    }
+    bootstrap.waiters += 1;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            signal?.removeEventListener("abort", abort);
+            callback();
+        };
+        const abort = () => {
+            finish(() => {
+                const reason = signal?.reason ?? new Error("Script command aborted.");
+                const drainsBootstrap = releaseWindowsJobHelperWaiter(bootstrap, reason);
+                if (drainsBootstrap) {
+                    void bootstrap.promise.then(() => reject(reason), () => reject(reason));
+                }
+                else {
+                    reject(reason);
+                }
+            });
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        void bootstrap.promise.then((value) => {
+            finish(() => {
+                releaseWindowsJobHelperWaiter(bootstrap);
+                resolve(value);
+            });
+        }, (error) => {
+            finish(() => {
+                releaseWindowsJobHelperWaiter(bootstrap);
+                reject(error);
+            });
+        });
+        if (signal?.aborted) {
+            abort();
+        }
+    });
+}
+function quoteWindowsArgument(value) {
+    if (!value) {
+        return '""';
+    }
+    if (!/[\s"]/u.test(value)) {
+        return value;
+    }
+    let quoted = '"';
+    let backslashes = 0;
+    for (const character of value) {
+        if (character === "\\") {
+            backslashes += 1;
+            continue;
+        }
+        if (character === '"') {
+            quoted += `${"\\".repeat(backslashes * 2 + 1)}"`;
+            backslashes = 0;
+            continue;
+        }
+        quoted += "\\".repeat(backslashes) + character;
+        backslashes = 0;
+    }
+    return `${quoted}${"\\".repeat(backslashes * 2)}"`;
+}
+function windowsShellCommand(command, shell) {
+    const resolvedShell = shell ?? process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe";
+    const shellCommand = quoteWindowsArgument(resolvedShell);
+    const shellName = path.win32.basename(resolvedShell).toLowerCase();
+    return {
+        commandLine: shellName === "cmd" || shellName === "cmd.exe"
+            ? `${shellCommand} /d /s /c "${command}"`
+            : `${shellCommand} -c ${quoteWindowsArgument(command)}`,
+        shell: resolvedShell,
+    };
+}
+async function spawnScriptChild(params, signal) {
+    const cwd = params.cwd ? path.resolve(params.cwd) : process.cwd();
+    let startedAtMs;
+    let child;
+    if (process.platform === "win32") {
+        const helperPath = await ensureWindowsJobHelper(signal);
+        if (signal?.aborted) {
+            throw signal.reason ?? new Error("Script command aborted.");
+        }
+        startedAtMs = Date.now();
+        const shellCommand = windowsShellCommand(params.command, params.shell);
+        child = spawn(helperPath, [], {
+            cwd,
+            env: {
+                ...process.env,
+                [WINDOWS_JOB_COMMAND_ENV]: Buffer.from(shellCommand.commandLine).toString("base64"),
+                [WINDOWS_JOB_SHELL_ENV]: Buffer.from(shellCommand.shell).toString("base64"),
+            },
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+    }
+    else {
+        startedAtMs = Date.now();
+        child = spawn(params.command, {
+            cwd,
+            env: process.env,
+            shell: params.shell ?? true,
+            detached: true,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    const observedAtMs = Date.now();
+    if (signal?.aborted) {
+        await terminateChild(child, startedAtMs, observedAtMs);
+        throw signal.reason ?? new Error("Script command aborted.");
+    }
+    return { child, observedAtMs, startedAtMs };
+}
 const ScriptMessageSchema = z.object({
     author: z.enum(["assistant", "system", "user"]),
     id: z.string().min(1),
@@ -29,56 +531,196 @@ const ScriptInboundResultSchema = z
 })
     .refine((result) => (result.timeout === true && result.message === undefined) ||
     (result.timeout !== true && result.message !== undefined), { message: "result must contain either a message or timeout: true" });
-async function terminateChild(child) {
-    if (process.platform === "win32" && child.pid) {
-        await new Promise((resolve) => {
-            let taskkill;
+function runTerminationCommand(command, args) {
+    return new Promise((resolve) => {
+        let cleanup;
+        try {
+            cleanup = spawn(command, args, {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        let settled = false;
+        const finish = (succeeded) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            resolve(succeeded);
+        };
+        const timeout = setTimeout(() => {
             try {
-                taskkill = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
-                    stdio: "ignore",
-                    windowsHide: true,
-                });
+                cleanup.kill("SIGKILL");
             }
             catch {
-                resolve();
-                return;
+                // The cleanup process may have exited at the timeout boundary.
             }
-            let settled = false;
-            const finish = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                clearTimeout(timeout);
-                resolve();
-            };
-            const timeout = setTimeout(() => {
-                taskkill.kill("SIGKILL");
-                finish();
-            }, WINDOWS_TERMINATION_TIMEOUT_MS);
-            timeout.unref();
-            taskkill.once("close", finish);
-            taskkill.once("error", finish);
-        });
-    }
-    else if (child.pid) {
+            finish(false);
+        }, WINDOWS_TERMINATION_COMMAND_TIMEOUT_MS);
+        timeout.unref();
+        cleanup.once("close", (code) => finish(code === 0));
+        cleanup.once("error", () => finish(false));
+    });
+}
+function windowsProcessTreeTermination(pid, childStartedAtMs, childObservedAtMs, rootExpectedAlive) {
+    const rootNotBeforeMs = Math.max(0, Math.floor(childStartedAtMs));
+    const rootObservedByMs = Math.max(rootNotBeforeMs, Math.ceil(childObservedAtMs) + 1);
+    return [
+        "$ErrorActionPreference='Stop'",
+        `$NativeSource='${WINDOWS_PROCESS_TERMINATOR_SOURCE}'`,
+        "Add-Type -TypeDefinition $NativeSource",
+        `$RootProcessId=${pid}`,
+        `$RootExpectedAlive=$${rootExpectedAlive ? "true" : "false"}`,
+        `$RootNotBefore=[DateTimeOffset]::FromUnixTimeMilliseconds(${rootNotBeforeMs}).UtcDateTime`,
+        `$RootObservedBy=[DateTimeOffset]::FromUnixTimeMilliseconds(${rootObservedByMs}).UtcDateTime`,
+        "$AllProcesses=@(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CreationDate)",
+        "$Snapshot=[System.Collections.Generic.List[object]]::new()",
+        "$Pending=[System.Collections.Generic.Queue[object]]::new()",
+        "$Visited=[System.Collections.Generic.HashSet[string]]::new()",
+        "$RootProcess=$AllProcesses | Where-Object { [int]$_.ProcessId -eq $RootProcessId } | Select-Object -First 1",
+        "$RootCreated=if($null -ne $RootProcess){([datetime]$RootProcess.CreationDate).ToUniversalTime()}else{$null}",
+        "$RootMatches=$null -ne $RootProcess -and $RootCreated -ge $RootNotBefore -and $RootCreated -le $RootObservedBy",
+        "$KillRoot=$RootExpectedAlive -and $RootMatches",
+        "$CleanupFailed=$RootExpectedAlive -and !$RootMatches",
+        "if($KillRoot){",
+        "$Snapshot.Add($RootProcess)",
+        '$Visited.Add("$([int]$RootProcess.ProcessId)|$(([datetime]$RootProcess.CreationDate).ToFileTimeUtc())") | Out-Null',
+        "$Pending.Enqueue($RootProcess)",
+        "}",
+        "while($Pending.Count -gt 0){",
+        "$Parent=$Pending.Dequeue()",
+        "foreach($Process in @($AllProcesses | Where-Object { [int]$_.ParentProcessId -eq [int]$Parent.ProcessId })){",
+        "$ChildCreated=([datetime]$Process.CreationDate).ToUniversalTime()",
+        "$ParentCreated=([datetime]$Parent.CreationDate).ToUniversalTime()",
+        "if($ChildCreated -lt $ParentCreated){continue}",
+        '$Identity="$([int]$Process.ProcessId)|$($ChildCreated.ToFileTimeUtc())"',
+        "if(!$Visited.Add($Identity)){continue}",
+        "$Snapshot.Add($Process)",
+        "$Pending.Enqueue($Process)",
+        "}",
+        "}",
+        "if($KillRoot){",
+        "$Entries=@($Snapshot)",
+        "[array]::Reverse($Entries)",
+        "foreach($Entry in $Entries){",
+        "$CreationTime=([datetime]$Entry.CreationDate).ToFileTimeUtc()",
+        "if(![CrablineProcessTerminator]::TerminateVerified([int]$Entry.ProcessId,$CreationTime)){$CleanupFailed=$true}",
+        "}",
+        "}",
+        "if($CleanupFailed){exit 1}",
+    ].join(";");
+}
+function destroyChildPipes(child) {
+    for (const stream of [child.stdin, child.stdout, child.stderr]) {
         try {
-            process.kill(-child.pid, "SIGKILL");
+            stream?.destroy();
         }
         catch {
-            // The process group may have exited with the shell.
+            // Pipe teardown is best effort after process-tree termination.
+        }
+    }
+}
+function isChildRunning(child) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return false;
+    }
+    try {
+        return child.kill(0);
+    }
+    catch {
+        return false;
+    }
+}
+async function terminateChild(child, childStartedAtMs, childObservedAtMs) {
+    try {
+        const childRunning = isChildRunning(child);
+        if (process.platform === "win32") {
+            if (child.pid) {
+                const treeTerminated = await runTerminationCommand("powershell.exe", [
+                    "-NoLogo",
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    windowsProcessTreeTermination(child.pid, childStartedAtMs, childObservedAtMs, childRunning),
+                ]);
+                if (!treeTerminated && isChildRunning(child)) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // Closing the helper handle is the bounded fallback for its Job Object.
+                    }
+                }
+            }
+        }
+        else if (child.pid) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch {
+                // The process group may have exited with the shell.
+            }
+        }
+        if (isChildRunning(child)) {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // The process may have exited while its descendants retained the pipes.
+            }
         }
     }
-    if (child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
+    finally {
+        destroyChildPipes(child);
     }
 }
+async function waitForChildClose(childClosed) {
+    let timeout;
+    const exit = await Promise.race([
+        childClosed,
+        new Promise((resolve) => {
+            timeout = setTimeout(() => resolve(undefined), CHILD_CLOSE_TIMEOUT_MS);
+            timeout.unref();
+        }),
+    ]);
+    clearTimeout(timeout);
+    return exit;
+}
+function waitForChildCloseOrAbort(childClosed, signals) {
+    const activeSignals = signals.filter((signal) => signal !== undefined);
+    if (activeSignals.some((signal) => signal.aborted)) {
+        return Promise.resolve(undefined);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const abort = () => finish(undefined);
+        const finish = (exit) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            for (const signal of activeSignals) {
+                signal.removeEventListener("abort", abort);
+            }
+            resolve(exit);
+        };
+        for (const signal of activeSignals) {
+            signal.addEventListener("abort", abort, { once: true });
+        }
+        void childClosed.then((exit) => finish(exit));
+    });
+}
 function formatValidationError(error) {
     return error.issues
         .map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "result"}: ${issue.message}`)
         .join("; ");
 }
-const sensitiveEnvironmentNameFragmentPattern = /(?:AUTH|BEARER|CREDENTIAL|KEY|PASS|PRIVATE|SECRET|TOKEN)/iu;
+const sensitiveEnvironmentNameFragmentPattern = /(?:AUTH|BEARER|CREDENTIAL|JWT|KEY|PASS|PRIVATE|SECRET|TOKEN)/iu;
 const nonSensitiveWorkingDirectoryNames = new Set(["PWD", "OLDPWD"]);
 function isSensitiveEnvironmentName(name) {
     const upperName = name.toUpperCase();
@@ -86,7 +728,20 @@ function isSensitiveEnvironmentName(name) {
         (!nonSensitiveWorkingDirectoryNames.has(upperName) && upperName.includes("PWD")) ||
         /PAT(?!H)/u.test(upperName));
 }
+function redactCredentialSyntax(detail) {
+    let redacted = detail.replace(/\b([a-z][a-z0-9+.-]*:\/\/)([^/\s@]+)@/giu, "$1[redacted credentials]@");
+    redacted = redacted.replace(/(\bauthorization\b["']?\s*[:=]\s*["']?\s*)(?:(basic|bearer)\s+)?([^\s"',;}]+)/giu, (_match, prefix, scheme) => `${prefix}${scheme ? `${scheme} ` : ""}[redacted credential]`);
+    redacted = redacted.replace(/\b([A-Za-z_][A-Za-z0-9_-]*)\s*(\+?=|:)\s*("[^"]*"|'[^']*'|[^,;}\]\r\n]+)/gu, (match, name, operator) => name.toLowerCase() !== "authorization" && isSensitiveEnvironmentName(name)
+        ? `${name}${operator}[redacted credential]`
+        : match);
+    return redacted.replace(/--([A-Za-z0-9][A-Za-z0-9_-]*)(=|\s+)("[^"]*"|'[^']*'|[^\s,;]+)/gu, (match, name, separator) => isSensitiveEnvironmentName(name.replaceAll("-", "_"))
+        ? `--${name}${separator}[redacted credential]`
+        : match);
+}
 function commandContainsSensitiveValue(command) {
+    if (redactCredentialSyntax(command) !== command) {
+        return true;
+    }
     const assignments = [
         ...command.matchAll(/(?:^|[\s;&|])["']?([A-Za-z_][A-Za-z0-9_]*)\s*\+?=/gu),
         ...command.matchAll(/\$env:([A-Za-z_][A-Za-z0-9_]*)\s*\+?=/giu),
@@ -97,6 +752,147 @@ function commandContainsSensitiveValue(command) {
     }
     return [...command.matchAll(/(?:^|[\s;&|])["']?--([A-Za-z0-9][A-Za-z0-9_-]*)(?:=|\s)/gu)].some((match) => isSensitiveEnvironmentName((match[1] ?? "").replaceAll("-", "_")));
 }
+function addRedactionRepresentations(values, value) {
+    if (!value) {
+        return;
+    }
+    values.add(value);
+    const serialized = JSON.stringify(value);
+    values.add(serialized);
+    values.add(serialized.slice(1, -1));
+}
+function addCommandValueRedactions(substringValues, value) {
+    addRedactionRepresentations(substringValues, value);
+}
+function tokenizeLiteralCommand(command) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\n" || character === "\r") {
+            return undefined;
+        }
+        if (process.platform === "win32" && character === "\\" && command[index + 1] === '"') {
+            return undefined;
+        }
+        if (process.platform === "win32" && character === '"' && command[index + 1] === '"') {
+            return undefined;
+        }
+        if (quote) {
+            if (character === quote) {
+                quote = undefined;
+                continue;
+            }
+            if (quote === '"' && /[$`%!]/u.test(character)) {
+                return undefined;
+            }
+            if (character === "\\" && quote === '"' && process.platform !== "win32") {
+                return undefined;
+            }
+            current += character;
+            continue;
+        }
+        if (character === '"' || (character === "'" && process.platform !== "win32")) {
+            quote = character;
+            continue;
+        }
+        if (/\s/u.test(character)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        if (/[;&|<>(){}$`%!*?[\]~]/u.test(character) ||
+            (process.platform === "win32" && character === "^")) {
+            return undefined;
+        }
+        if (character === "\\") {
+            if (process.platform !== "win32") {
+                return undefined;
+            }
+        }
+        current += character;
+    }
+    if (quote) {
+        return undefined;
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function snapshotCommandValues(command) {
+    const tokens = tokenizeLiteralCommand(command);
+    if (!tokens) {
+        return undefined;
+    }
+    const exactValues = new Set();
+    const substringValues = new Set();
+    let executableSeen = false;
+    for (const token of tokens) {
+        if (!executableSeen) {
+            const assignment = /^([A-Za-z_][A-Za-z0-9_]*)\+?=(.*)$/u.exec(token);
+            if (assignment) {
+                addCommandValueRedactions(substringValues, assignment[2] ?? "");
+                continue;
+            }
+            executableSeen = true;
+            continue;
+        }
+        if (/^--[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(token)) {
+            const value = token.slice(2);
+            if (value.length < 3) {
+                return undefined;
+            }
+            addRedactionRepresentations(exactValues, token);
+            addCommandValueRedactions(substringValues, value);
+            continue;
+        }
+        if (/^-[A-Za-z0-9][A-Za-z0-9_-]+$/u.test(token)) {
+            const value = token.slice(2);
+            if (value.length < 3) {
+                return undefined;
+            }
+            addRedactionRepresentations(exactValues, token);
+            addCommandValueRedactions(substringValues, token.slice(1));
+            addCommandValueRedactions(substringValues, value);
+            continue;
+        }
+        const option = /^--?[A-Za-z0-9][A-Za-z0-9_-]*=(.*)$/u.exec(token);
+        if (option) {
+            const value = option[1] ?? "";
+            if (value.length < 3) {
+                return undefined;
+            }
+            addCommandValueRedactions(substringValues, value);
+            continue;
+        }
+        if (process.platform === "win32" && token.startsWith("/")) {
+            const slashOption = /^\/[A-Za-z0-9][A-Za-z0-9_-]*[:=](.*)$/u.exec(token);
+            const value = slashOption?.[1] ?? "";
+            if (value.length < 3) {
+                return undefined;
+            }
+            addCommandValueRedactions(substringValues, value);
+            continue;
+        }
+        if (token.length < 3) {
+            return undefined;
+        }
+        if (token.startsWith("-")) {
+            return undefined;
+        }
+        else {
+            addRedactionRepresentations(substringValues, token);
+        }
+    }
+    return {
+        exactValues: [...exactValues].sort((left, right) => right.length - left.length),
+        substringValues: [...substringValues].sort((left, right) => right.length - left.length),
+    };
+}
 function snapshotSensitiveEnvironmentValues() {
     const representations = new Set();
     const values = Object.entries(process.env)
@@ -104,19 +900,10 @@ function snapshotSensitiveEnvironmentValues() {
         .map(([, value]) => value)
         .sort((left, right) => right.length - left.length);
     for (const value of values) {
-        representations.add(value);
-        representations.add(JSON.stringify(value));
-        representations.add(JSON.stringify(value).slice(1, -1));
+        addRedactionRepresentations(representations, value);
     }
     return [...representations].sort((left, right) => right.length - left.length);
 }
-function redactSensitiveEnvironmentValues(detail, sensitiveEnvironmentValues) {
-    let redacted = detail;
-    for (const representation of sensitiveEnvironmentValues) {
-        redacted = redacted.split(representation).join("[redacted environment value]");
-    }
-    return redacted;
-}
 function collectSensitivePayloadValues(value, values, seen, sensitive = false) {
     if (typeof value === "string") {
         if (sensitive && value.length > 0) {
@@ -157,10 +944,54 @@ function snapshotSensitivePayloadValues(payload) {
     });
     return [...values].sort((left, right) => right.length - left.length);
 }
-function redactSensitivePayloadValues(detail, sensitivePayloadValues) {
+function isExactCommandValueBoundary(character) {
+    return character === undefined || /[\s"'`=,:;.()[\]{}<>!?]/u.test(character);
+}
+function collectDiagnosticRedactionSpans(detail, values, label, priority, exact = false) {
+    const spans = [];
+    for (const value of values) {
+        let cursor = 0;
+        while (cursor < detail.length) {
+            const start = detail.indexOf(value, cursor);
+            if (start < 0) {
+                break;
+            }
+            const end = start + value.length;
+            if (!exact ||
+                (isExactCommandValueBoundary(detail[start - 1]) && isExactCommandValueBoundary(detail[end]))) {
+                spans.push({ end, label, priority, sourceLength: value.length, start });
+            }
+            cursor = end;
+        }
+    }
+    return spans;
+}
+function redactDiagnosticValues(detail, diagnostics) {
+    const spans = [
+        ...collectDiagnosticRedactionSpans(detail, diagnostics.sensitiveEnvironmentValues, "[redacted environment value]", 4),
+        ...collectDiagnosticRedactionSpans(detail, diagnostics.configuredCommands, "[configured script command]", 3),
+        ...collectDiagnosticRedactionSpans(detail, diagnostics.commandValues, "[redacted command value]", 3),
+        ...collectDiagnosticRedactionSpans(detail, diagnostics.exactCommandValues, "[redacted command value]", 3, true),
+        ...collectDiagnosticRedactionSpans(detail, diagnostics.sensitivePayloadValues, "[redacted configured value]", 2),
+    ].sort((left, right) => left.start - right.start || right.end - left.end || right.priority - left.priority);
+    const merged = [];
+    for (const span of spans) {
+        const previous = merged.at(-1);
+        if (!previous || span.start >= previous.end) {
+            merged.push({ ...span });
+            continue;
+        }
+        previous.end = Math.max(previous.end, span.end);
+        if (span.sourceLength > previous.sourceLength ||
+            (span.sourceLength === previous.sourceLength && span.priority > previous.priority)) {
+            previous.label = span.label;
+            previous.priority = span.priority;
+            previous.sourceLength = span.sourceLength;
+        }
+    }
     let redacted = detail;
-    for (const value of sensitivePayloadValues) {
-        redacted = redacted.split(value).join("[redacted configured value]");
+    for (const span of merged.toReversed()) {
+        redacted = redacted.slice(0, span.start) + span.label + redacted.slice(span.end);
     }
     return redacted;
 }
@@ -168,17 +999,25 @@ function formatScriptError(summary, detail, command, diagnostics) {
     if (!detail.trim()) {
         return summary;
     }
-    if (commandContainsSensitiveValue(command)) {
+    if (!diagnostics.diagnosticsSafe || commandContainsSensitiveValue(command)) {
         return `${summary}\n[script diagnostics redacted]`;
     }
-    let redacted = redactSensitivePayloadValues(redactSensitiveEnvironmentValues(detail, diagnostics.sensitiveEnvironmentValues), diagnostics.sensitivePayloadValues);
-    for (const configuredCommand of diagnostics.configuredCommands) {
-        redacted = redacted.split(configuredCommand).join("[configured script command]");
-    }
+    let redacted = redactDiagnosticValues(detail, diagnostics);
+    redacted = redactCredentialSyntax(redacted);
     redacted = redacted.trim();
     return redacted ? `${summary}\n${redacted}` : summary;
 }
-function createScriptDiagnosticsSnapshot(command, serializedPayload) {
+function usesSupportedDiagnosticShell(shell) {
+    if (shell !== undefined) {
+        return false;
+    }
+    if (process.platform !== "win32") {
+        return true;
+    }
+    const comspec = process.env.ComSpec ?? process.env.COMSPEC;
+    return comspec === undefined || /(?:^|[\\/])cmd(?:\.exe)?$/iu.test(comspec);
+}
+function createScriptDiagnosticsSnapshot(command, serializedPayload, shell) {
     const payload = JSON.parse(serializedPayload);
     const configuredCommands = new Set([command]);
     const commands = payload.provider?.config?.script?.commands;
@@ -187,8 +1026,30 @@ function createScriptDiagnosticsSnapshot(command, serializedPayload) {
             configuredCommands.add(configuredCommand);
         }
     }
+    const commandValues = new Set();
+    const exactCommandValues = new Set();
+    let diagnosticsSafe = usesSupportedDiagnosticShell(shell);
+    for (const configuredCommand of configuredCommands) {
+        if (commandContainsSensitiveValue(configuredCommand)) {
+            diagnosticsSafe = false;
+        }
+        const values = snapshotCommandValues(configuredCommand);
+        if (!values) {
+            diagnosticsSafe = false;
+            continue;
+        }
+        for (const value of values.substringValues) {
+            commandValues.add(value);
+        }
+        for (const value of values.exactValues) {
+            exactCommandValues.add(value);
+        }
+    }
     return {
+        commandValues: [...commandValues].sort((left, right) => right.length - left.length),
         configuredCommands: [...configuredCommands].sort((left, right) => right.length - left.length),
+        diagnosticsSafe,
+        exactCommandValues: [...exactCommandValues].sort((left, right) => right.length - left.length),
         sensitiveEnvironmentValues: snapshotSensitiveEnvironmentValues(),
         sensitivePayloadValues: snapshotSensitivePayloadValues(payload),
     };
@@ -212,34 +1073,20 @@ function runScript(params) {
         return Promise.reject(params.signal.reason ?? new Error("Script command aborted."));
     }
     const serializedPayload = JSON.stringify(params.payload);
-    const diagnostics = createScriptDiagnosticsSnapshot(params.command, serializedPayload);
+    const diagnostics = createScriptDiagnosticsSnapshot(params.command, serializedPayload, params.shell);
     return new Promise((resolve, reject) => {
         let child;
-        try {
-            child = spawn(params.command, {
-                cwd: params.cwd ? path.resolve(params.cwd) : process.cwd(),
-                env: process.env,
-                shell: params.shell ?? true,
-                detached: process.platform !== "win32",
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            reject(new CrablineError(formatScriptError("Script command failed to start.", ensureErrorMessage(error), params.command, diagnostics), { kind: "connectivity" }));
-            return;
-        }
+        let childStartedAtMs = 0;
+        let childObservedAtMs = 0;
         const stdout = [];
         const stderr = [];
         let deadlineExceeded = false;
         let outputBytes = 0;
         let settled = false;
+        let timeout;
         let timeoutGrace;
-        const abort = () => {
-            finish(async () => {
-                await terminateChild(child);
-                reject(params.signal?.reason ?? new Error("Script command aborted."));
-            });
-        };
+        const spawnAbortController = new AbortController();
+        let spawnCompletion;
         const finish = (callback) => {
             if (settled) {
                 return;
@@ -247,80 +1094,98 @@ function runScript(params) {
             settled = true;
             clearTimeout(timeout);
             clearTimeout(timeoutGrace);
+            spawnAbortController.abort();
             params.signal?.removeEventListener("abort", abort);
             void callback();
         };
+        const stopChild = async () => {
+            if (child) {
+                await terminateChild(child, childStartedAtMs, childObservedAtMs);
+            }
+            else {
+                await spawnCompletion;
+            }
+        };
+        const abort = () => {
+            finish(async () => {
+                await stopChild();
+                reject(params.signal?.reason ?? new Error("Script command aborted."));
+            });
+        };
         const failForOutputLimit = () => {
             finish(async () => {
-                await terminateChild(child);
+                await stopChild();
                 reject(new CrablineError(`Script command exceeded ${MAX_SCRIPT_OUTPUT_BYTES} bytes of output.`, {
                     kind: "connectivity",
                 }));
             });
         };
-        child.stdout.on("data", (chunk) => {
-            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            outputBytes += buffer.length;
-            if (outputBytes > MAX_SCRIPT_OUTPUT_BYTES) {
-                failForOutputLimit();
-                return;
-            }
-            stdout.push(buffer);
-        });
-        child.stderr.on("data", (chunk) => {
-            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            outputBytes += buffer.length;
-            if (outputBytes > MAX_SCRIPT_OUTPUT_BYTES) {
-                failForOutputLimit();
-                return;
-            }
-            stderr.push(buffer);
-        });
-        child.stdin.on("error", () => {
-            // Child closure is reported through the process error/close handlers.
-        });
-        child.once("error", (error) => {
-            finish(() => {
-                reject(new CrablineError(formatScriptError("Script command failed to start.", ensureErrorMessage(error), params.command, diagnostics), { kind: "connectivity" }));
+        const startChild = (spawnedChild) => {
+            spawnedChild.stdout.on("data", (chunk) => {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                outputBytes += buffer.length;
+                if (outputBytes > MAX_SCRIPT_OUTPUT_BYTES) {
+                    failForOutputLimit();
+                    return;
+                }
+                stdout.push(buffer);
             });
-        });
-        child.once("close", (code, signal) => {
-            finish(() => {
-                const stdoutText = Buffer.concat(stdout).toString("utf8");
-                const stderrText = Buffer.concat(stderr).toString("utf8");
-                if (code !== 0) {
-                    reject(new CrablineError(formatScriptError(`Script command failed${signal ? ` (${signal})` : ""}.`, stderrText.trim() ? stderrText : stdoutText, params.command, diagnostics), { kind: "connectivity" }));
+            spawnedChild.stderr.on("data", (chunk) => {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                outputBytes += buffer.length;
+                if (outputBytes > MAX_SCRIPT_OUTPUT_BYTES) {
+                    failForOutputLimit();
                     return;
                 }
-                try {
-                    const result = parseScriptJson({
-                        command: params.command,
-                        diagnostics,
-                        output: stdoutText,
-                        schema: params.schema,
-                    });
-                    if (deadlineExceeded && !params.acceptResultDuringTimeoutGrace?.(result)) {
-                        reject(new CrablineError(`Script command timed out after ${params.timeoutMs}ms.`, {
-                            kind: "timeout",
-                        }));
+                stderr.push(buffer);
+            });
+            spawnedChild.stdin.on("error", () => {
+                // Child closure is reported through the process error/close handlers.
+            });
+            spawnedChild.once("error", (error) => {
+                finish(() => {
+                    reject(new CrablineError(formatScriptError("Script command failed to start.", ensureErrorMessage(error), params.command, diagnostics), { kind: "connectivity" }));
+                });
+            });
+            spawnedChild.once("close", (code, signal) => {
+                finish(() => {
+                    const stdoutText = Buffer.concat(stdout).toString("utf8");
+                    const stderrText = Buffer.concat(stderr).toString("utf8");
+                    if (code !== 0) {
+                        reject(new CrablineError(formatScriptError(`Script command failed${signal ? ` (${signal})` : ""}.`, stderrText.trim() ? stderrText : stdoutText, params.command, diagnostics), { kind: "connectivity" }));
                         return;
                     }
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
+                    try {
+                        const result = parseScriptJson({
+                            command: params.command,
+                            diagnostics,
+                            output: stdoutText,
+                            schema: params.schema,
+                        });
+                        if (deadlineExceeded && !params.acceptResultDuringTimeoutGrace?.(result)) {
+                            reject(new CrablineError(`Script command timed out after ${params.timeoutMs}ms.`, {
+                                kind: "timeout",
+                            }));
+                            return;
+                        }
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
             });
-        });
+            spawnedChild.stdin.end(serializedPayload);
+        };
         const failForTimeout = () => {
             finish(async () => {
-                await terminateChild(child);
+                await stopChild();
                 reject(new CrablineError(`Script command timed out after ${params.timeoutMs}ms.`, {
                     kind: "timeout",
                 }));
             });
         };
-        const timeout = setTimeout(() => {
+        timeout = setTimeout(() => {
             const timeoutGraceMs = params.timeoutGraceMs ?? 0;
             if (timeoutGraceMs <= 0) {
                 failForTimeout();
@@ -331,12 +1196,28 @@ function runScript(params) {
             timeoutGrace.unref();
         }, params.timeoutMs);
         timeout.unref();
+        params.signal?.addEventListener("abort", abort, { once: true });
         if (params.signal?.aborted) {
             abort();
             return;
         }
-        params.signal?.addEventListener("abort", abort, { once: true });
-        child.stdin.end(serializedPayload);
+        spawnCompletion = spawnScriptChild(params, spawnAbortController.signal).then(async (spawned) => {
+            if (settled) {
+                await terminateChild(spawned.child, spawned.startedAtMs, spawned.observedAtMs);
+                return;
+            }
+            child = spawned.child;
+            childStartedAtMs = spawned.startedAtMs;
+            childObservedAtMs = spawned.observedAtMs;
+            startChild(spawned.child);
+        }, (error) => {
+            if (settled) {
+                return;
+            }
+            finish(() => {
+                reject(new CrablineError(formatScriptError("Script command failed to start.", ensureErrorMessage(error), params.command, diagnostics), { kind: "connectivity" }));
+            });
+        });
     });
 }
 function watchScript(params) {
@@ -355,31 +1236,45 @@ function watchScript(params) {
             },
         };
         const serializedPayload = JSON.stringify(payload);
-        const diagnostics = createScriptDiagnosticsSnapshot(params.command, serializedPayload);
+        const diagnostics = createScriptDiagnosticsSnapshot(params.command, serializedPayload, params.shell);
         let child;
+        let childStartedAtMs;
+        let childObservedAtMs;
+        const spawnSignal = params.context.signal
+            ? AbortSignal.any([params.cancelSignal, params.context.signal])
+            : params.cancelSignal;
         try {
-            child = spawn(params.command, {
-                cwd: params.cwd ? path.resolve(params.cwd) : process.cwd(),
-                env: process.env,
-                shell: params.shell ?? true,
-                detached: process.platform !== "win32",
-                stdio: ["pipe", "pipe", "pipe"],
-            });
+            ({
+                child,
+                observedAtMs: childObservedAtMs,
+                startedAtMs: childStartedAtMs,
+            } = await spawnScriptChild(params, spawnSignal));
         }
         catch (error) {
+            if (params.cancelSignal.aborted) {
+                return;
+            }
+            if (params.context.signal?.aborted) {
+                throw params.context.signal.reason ?? new Error("Script watch command aborted.");
+            }
             throw new CrablineError(formatScriptError("Script watch command failed to start.", ensureErrorMessage(error), params.command, diagnostics), { kind: "connectivity" });
         }
         let buffer = "";
         let stderr = "";
         let childError;
         let outputLimitError;
+        let termination;
         const stopChild = () => {
-            void terminateChild(child);
+            termination ??= terminateChild(child, childStartedAtMs, childObservedAtMs);
+            return termination;
         };
-        params.cancelSignal.addEventListener("abort", stopChild, { once: true });
-        params.context.signal?.addEventListener("abort", stopChild, { once: true });
+        const requestStopChild = () => {
+            void stopChild();
+        };
+        params.cancelSignal.addEventListener("abort", requestStopChild, { once: true });
+        params.context.signal?.addEventListener("abort", requestStopChild, { once: true });
         if (params.cancelSignal.aborted || params.context.signal?.aborted) {
-            stopChild();
+            requestStopChild();
         }
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
@@ -393,7 +1288,7 @@ function watchScript(params) {
             stderr += chunk;
             if (Buffer.byteLength(stderr) > MAX_SCRIPT_OUTPUT_BYTES) {
                 outputLimitError = new CrablineError(`Script watch command exceeded ${MAX_SCRIPT_OUTPUT_BYTES} bytes of stderr.`, { kind: "connectivity" });
-                void terminateChild(child);
+                requestStopChild();
             }
         });
         child.once("error", (error) => {
@@ -452,13 +1347,29 @@ function watchScript(params) {
                     provider: params.id,
                 };
             }
-            const exit = await childClosed;
             if (outputLimitError) {
+                await stopChild();
+                await waitForChildClose(childClosed);
                 throw outputLimitError;
             }
             if (childError) {
+                await waitForChildClose(childClosed);
                 throw new CrablineError(formatScriptError("Script watch command failed to start.", ensureErrorMessage(childError), params.command, diagnostics), { kind: "connectivity" });
             }
+            const exit = await waitForChildCloseOrAbort(childClosed, [
+                params.cancelSignal,
+                params.context.signal,
+            ]);
+            if (!exit) {
+                await stopChild();
+                if (params.cancelSignal.aborted) {
+                    return;
+                }
+                if (params.context.signal?.aborted) {
+                    throw params.context.signal.reason ?? new Error("Script watch command aborted.");
+                }
+                return;
+            }
             if (exit.code !== 0) {
                 throw new CrablineError(formatScriptError(`Script watch command failed${exit.signal ? ` (${exit.signal})` : ""}.`, stderr, params.command, diagnostics), { kind: "connectivity" });
             }
@@ -476,13 +1387,13 @@ function watchScript(params) {
             throw error;
         }
         finally {
-            params.cancelSignal.removeEventListener("abort", stopChild);
-            params.context.signal?.removeEventListener("abort", stopChild);
+            params.cancelSignal.removeEventListener("abort", requestStopChild);
+            params.context.signal?.removeEventListener("abort", requestStopChild);
             child.stdin.destroy();
             if (!childCloseObserved) {
-                await terminateChild(child);
+                await stopChild();
             }
-            await childClosed;
+            await waitForChildClose(childClosed);
         }
     })();
 }