@codyswann/lisa 4.60.10 → 4.60.12

package/all/copy-overwrite/scripts/lib/process-tree-runner.mjs

@@ -3,14 +3,18 @@
 // Do not edit directly — durable changes belong upstream in Lisa.
 
 /**
- * Run one shell command in its own process group and reap the whole group.
+ * Run one shell command in a process boundary and reap every descendant.
  *
  * Node's synchronous timeout signals only the direct child. A gate command is
  * a tree (shell, package manager, test workers), so killing only the shell
  * leaves descendants running against scratch state the caller then removes.
  * This small asynchronous supervisor is invoked through a synchronous parent:
  * it owns the process-group id, applies the deadline, terminates the group, and
- * only then lets the parent continue.
+ * only then lets the parent continue. On Windows, the common PowerShell helper
+ * owns a native Job Object because a shell PID cannot identify descendants
+ * after the shell exits. Windows 10 / Server 2016 or newer and the installed
+ * Windows PowerShell execution policy must permit that helper; startup failure
+ * rejects the command without an uncontained fallback.
  *
  * ## Interrupting a run
  *
@@ -31,6 +35,7 @@
 import { spawn, spawnSync } from "node:child_process";
 
 import { invokedAsScript } from "./invoked-as-script.mjs";
+import { startWindowsProcessJob } from "./windows-process-job.mjs";
 
 const KILL_GRACE_MS = 750;
 const REAP_POLL_MS = 25;
@@ -407,7 +412,7 @@ export async function reapTree(pid, controls = DEFAULT_REAP_CONTROLS) {
  * lands on a recycled pid.
  * @param {string} command Shell source to supervise.
  * @param {number} timeoutMs Deadline for the whole tree.
- * @param {typeof reapTree} [reap] Injectable group reaper.
+ * @param {typeof reapTree} [reap] Injectable POSIX group reaper. Windows retains its native job owner.
  * @param {object} [options] Interrupt-watch seams, injectable for tests.
  * @param {readonly number[]} [options.watchPids] Pids whose death ends this run.
  * @param {typeof interruptionReason} [options.detect] Interrupt predicate.
@@ -425,14 +430,7 @@ export function supervise(command, timeoutMs, reap = reapTree, options = {}) {
     launchParentPid = process.ppid,
   } = options;
   return new Promise((resolve, reject) => {
-    const shell =
-      process.platform === "win32"
-        ? process.env.ComSpec || "cmd.exe"
-        : "/bin/sh";
-    const shellArgs =
-      process.platform === "win32"
-        ? ["/d", "/s", "/c", command]
-        : ["-c", command];
+    let windowsJob;
     let pendingSignal;
     let dispatchSignal = signal => {
       pendingSignal ??= signal;
@@ -455,7 +453,11 @@ export function supervise(command, timeoutMs, reap = reapTree, options = {}) {
 
     const child = (() => {
       try {
-        return spawn(shell, shellArgs, {
+        if (process.platform === "win32") {
+          windowsJob = startWindowsProcessJob(command);
+          return windowsJob.child;
+        }
+        return spawn("/bin/sh", ["-c", command], {
           detached: true,
           env: process.env,
           stdio: "inherit",
@@ -501,7 +503,7 @@ export function supervise(command, timeoutMs, reap = reapTree, options = {}) {
     // shell's close handler is reaping must join that operation instead of
     // starting a second kill sequence or taking the default signal action.
     const reapOnce = () => {
-      reapPromise ??= reap(pid);
+      reapPromise ??= windowsJob ? windowsJob.reap() : reap(pid);
       return reapPromise;
     };
     const finish = async (code, signal) => {

package/all/copy-overwrite/scripts/lib/windows-process-job.cs

@@ -0,0 +1,249 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+// Windows 10 / Server 2016 or newer: create the shell inside its Job Object.
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+/// <summary>Runs a shell inside a retained job and confirms its descendants have exited.</summary>
+public static class LisaWindowsProcessJob
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct BasicLimits
+    {
+        public long ProcessTime, JobTime;
+        public uint Flags;
+        public UIntPtr MinimumWorkingSet, MaximumWorkingSet;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint Priority, SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct ExtendedLimits
+    {
+        public BasicLimits Basic;
+        public ulong ReadOperations, WriteOperations, OtherOperations;
+        public ulong ReadBytes, WriteBytes, OtherBytes;
+        public UIntPtr ProcessMemory, JobMemory, PeakProcessMemory, PeakJobMemory;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct Accounting
+    {
+        public long UserTime, KernelTime, PeriodUserTime, PeriodKernelTime;
+        public uint PageFaults, TotalProcesses, ActiveProcesses, TerminatedProcesses;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct StartupInfo
+    {
+        public uint Size;
+        public IntPtr Reserved, Desktop, Title;
+        public uint X, Y, Width, Height, XCount, YCount, Fill, Flags;
+        public ushort ShowWindow, ReservedLength;
+        public IntPtr ReservedData, Input, Output, Error;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct StartupInfoEx
+    {
+        public StartupInfo Startup;
+        public IntPtr Attributes;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct ProcessInformation
+    {
+        public IntPtr Process, Thread;
+        public uint ProcessId, ThreadId;
+    }
+
+    /// <summary>Creates the helper-owned job handle, which is never inherited by the shell.</summary>
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
+    /// <summary>Applies the job limits used to kill members when its final handle closes.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool SetInformationJobObject(IntPtr job, int kind, ref ExtendedLimits value, uint size);
+    /// <summary>Reads job accounting so cleanup can confirm zero active processes.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool QueryInformationJobObject(IntPtr job, int kind, out Accounting value, uint size, IntPtr returned);
+    /// <summary>Requests termination of every process retained in the job.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool TerminateJobObject(IntPtr job, uint code);
+    /// <summary>Measures or initializes storage for the two process-creation attributes.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, uint flags, ref IntPtr size);
+    /// <summary>Adds the job binding or restricted inherited-handle list before process creation.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr attribute, IntPtr value, IntPtr size, IntPtr previous, IntPtr returned);
+    /// <summary>Releases initialized attribute-list contents before their backing memory is freed.</summary>
+    [DllImport("kernel32.dll")]
+    static extern void DeleteProcThreadAttributeList(IntPtr list);
+    /// <summary>Creates the shell with job membership and explicit standard handles already assigned.</summary>
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern bool CreateProcessW(string application, StringBuilder command, IntPtr processAttributes, IntPtr threadAttributes, bool inheritHandles, uint flags, IntPtr environment, string directory, ref StartupInfoEx startup, out ProcessInformation process);
+    /// <summary>Polls the shell handle while allowing stop-file and owner-exit checks.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+    /// <summary>Reads the shell exit code after its process handle signals completion.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool GetExitCodeProcess(IntPtr process, out uint code);
+    /// <summary>Releases an owned native handle without closing borrowed caller handles.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool CloseHandle(IntPtr handle);
+    /// <summary>Supplies the current-process pseudo handle for standard-handle duplication.</summary>
+    [DllImport("kernel32.dll")]
+    static extern IntPtr GetCurrentProcess();
+    /// <summary>Reads a borrowed standard handle, which may be absent in a service process.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern IntPtr GetStdHandle(int kind);
+    /// <summary>Opens a temporary NUL device handle when a standard stream is absent.</summary>
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern IntPtr CreateFileW(string name, uint access, uint share, IntPtr attributes, uint creation, uint flags, IntPtr template);
+    /// <summary>Creates an inheritable duplicate while retaining ownership of the original handle.</summary>
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool DuplicateHandle(IntPtr sourceProcess, IntPtr source, IntPtr targetProcess, out IntPtr target, uint access, bool inherit, uint options);
+
+    /// <summary>Throws with the captured native error when an operation reports failure.</summary>
+    static void Check(bool ok, string operation)
+    {
+        if (!ok) throw new Win32Exception(Marshal.GetLastWin32Error(), operation);
+    }
+
+    /// <summary>Returns an owned inheritable standard handle, substituting NUL only when absent.</summary>
+    /// <param name="kind">The native standard-input, output, or error handle identifier.</param>
+    /// <returns>A duplicate that Run must close after the contained command finishes.</returns>
+    static IntPtr StandardHandle(int kind)
+    {
+        IntPtr source = GetStdHandle(kind);
+        bool absent = source == IntPtr.Zero || source == new IntPtr(-1);
+        if (absent)
+        {
+            // Services may have no standard handles. Supply EOF/discard devices
+            // while preserving any real redirected handles supplied by callers.
+            source = CreateFileW("NUL", kind == -10 ? 0x80000000u : 0x40000000u, 3, IntPtr.Zero, 3, 0, IntPtr.Zero);
+            Check(source != new IntPtr(-1), "Open absent gate standard handle");
+        }
+        try
+        {
+            IntPtr result;
+            Check(DuplicateHandle(GetCurrentProcess(), source, GetCurrentProcess(), out result, 0, true, 2), "Duplicate gate standard handle");
+            return result;
+        }
+        finally
+        {
+            if (absent) CloseHandle(source);
+        }
+    }
+
+    /// <summary>Terminates job members and waits up to five seconds for empty membership.</summary>
+    /// <param name="job">The retained job handle; this method does not close it.</param>
+    static void TerminateAndWait(IntPtr job)
+    {
+        Check(TerminateJobObject(job, 255), "Terminate gate job");
+        Stopwatch deadline = Stopwatch.StartNew();
+        for (;;)
+        {
+            Accounting state;
+            Check(QueryInformationJobObject(job, 1, out state, (uint)Marshal.SizeOf(typeof(Accounting)), IntPtr.Zero), "Read gate job membership");
+            if (state.ActiveProcesses == 0) return;
+            if (deadline.ElapsedMilliseconds >= 5000) throw new TimeoutException("Gate job still has processes after termination");
+            Thread.Sleep(25);
+        }
+    }
+
+    /// <summary>Runs a contained command and reaps its descendants before returning.</summary>
+    /// <remarks>
+    /// The helper owns the job outside its membership. A helper crash closes
+    /// its non-inherited job handle and kills the job as a backstop.
+    /// </remarks>
+    /// <param name="command">The shell command, forwarded without rewriting its arguments.</param>
+    /// <param name="controlDirectory">The caller-owned directory containing the stop marker.</param>
+    /// <param name="parent">The retained owner process whose exit requests cancellation.</param>
+    /// <returns>The shell exit code, or 255 when interrupted before normal completion.</returns>
+    public static int Run(string command, string controlDirectory, Process parent)
+    {
+        IntPtr job = IntPtr.Zero, attributes = IntPtr.Zero;
+        IntPtr jobValue = IntPtr.Zero, handleValues = IntPtr.Zero;
+        bool attributesInitialized = false;
+        IntPtr[] standard = new IntPtr[3];
+        ProcessInformation child = new ProcessInformation();
+        uint result = 255;
+        try
+        {
+            job = CreateJobObjectW(IntPtr.Zero, null);
+            Check(job != IntPtr.Zero, "Create gate job");
+            ExtendedLimits limits = new ExtendedLimits();
+            limits.Basic.Flags = 0x2000; // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE.
+            Check(SetInformationJobObject(job, 9, ref limits, (uint)Marshal.SizeOf(typeof(ExtendedLimits))), "Set gate job lifetime");
+
+            IntPtr size = IntPtr.Zero;
+            InitializeProcThreadAttributeList(IntPtr.Zero, 2, 0, ref size);
+            Check(size != IntPtr.Zero, "Measure gate process attributes");
+            attributes = Marshal.AllocHGlobal(size);
+            Check(InitializeProcThreadAttributeList(attributes, 2, 0, ref size), "Initialize gate process attributes");
+            attributesInitialized = true;
+            jobValue = Marshal.AllocHGlobal(IntPtr.Size);
+            Marshal.WriteIntPtr(jobValue, job);
+            // PROC_THREAD_ATTRIBUTE_JOB_LIST binds before the first instruction;
+            // suspended-create followed by assignment has an orphaning window.
+            Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(0x2000D), jobValue, new IntPtr(IntPtr.Size), IntPtr.Zero, IntPtr.Zero), "Bind gate to job at creation");
+
+            handleValues = Marshal.AllocHGlobal(3 * IntPtr.Size);
+            for (int i = 0; i < 3; ++i)
+            {
+                standard[i] = StandardHandle(-10 - i);
+                Marshal.WriteIntPtr(handleValues, i * IntPtr.Size, standard[i]);
+            }
+            Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(0x20002), handleValues, new IntPtr(3 * IntPtr.Size), IntPtr.Zero, IntPtr.Zero), "Limit inherited gate handles");
+            StartupInfoEx startup = new StartupInfoEx();
+            startup.Startup.Size = (uint)Marshal.SizeOf(typeof(StartupInfoEx));
+            startup.Startup.Flags = 0x100; // STARTF_USESTDHANDLES.
+            startup.Startup.Input = standard[0];
+            startup.Startup.Output = standard[1];
+            startup.Startup.Error = standard[2];
+            startup.Attributes = attributes;
+            string shell = Environment.GetEnvironmentVariable("ComSpec") ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe");
+            StringBuilder line = new StringBuilder("\"" + shell + "\" /d /s /c \"" + command + "\"");
+            // Never launch a command after a stop or owner exit during startup.
+            if (File.Exists(Path.Combine(controlDirectory, "stop")) || parent.WaitForExit(0)) return 255;
+            Check(CreateProcessW(shell, line, IntPtr.Zero, IntPtr.Zero, true, 0x80000, IntPtr.Zero, Environment.CurrentDirectory, ref startup, out child), "Create contained gate command");
+            for (;;)
+            {
+                uint wait = WaitForSingleObject(child.Process, 25);
+                if (wait == 0)
+                {
+                    Check(GetExitCodeProcess(child.Process, out result), "Read gate command exit");
+                    break;
+                }
+                Check(wait == 258, "Wait for gate command");
+                if (File.Exists(Path.Combine(controlDirectory, "stop")) || parent.WaitForExit(0)) break;
+            }
+        }
+        finally
+        {
+            // Release our process handles before checking membership accounting.
+            if (child.Thread != IntPtr.Zero) CloseHandle(child.Thread);
+            if (child.Process != IntPtr.Zero) CloseHandle(child.Process);
+            try
+            {
+                if (job != IntPtr.Zero) TerminateAndWait(job);
+            }
+            finally
+            {
+                if (job != IntPtr.Zero) CloseHandle(job);
+                foreach (IntPtr handle in standard) if (handle != IntPtr.Zero) CloseHandle(handle);
+                if (attributesInitialized) DeleteProcThreadAttributeList(attributes);
+                if (attributes != IntPtr.Zero) Marshal.FreeHGlobal(attributes);
+                if (jobValue != IntPtr.Zero) Marshal.FreeHGlobal(jobValue);
+                if (handleValues != IntPtr.Zero) Marshal.FreeHGlobal(handleValues);
+            }
+        }
+        return unchecked((int)result);
+    }
+}

package/all/copy-overwrite/scripts/lib/windows-process-job.mjs

@@ -0,0 +1,119 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+// The Windows-only helper owns a Job Object until all of its processes exit.
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { env } from "node:process";
+import { fileURLToPath } from "node:url";
+
+const CLEANUP_TIMEOUT_MS = 30000;
+
+/**
+ * Launch the Windows shell in a native job and return its cleanup operation.
+ * @param {string} command Shell source to run.
+ * @returns {{child: import("node:child_process").ChildProcess, reap: () => Promise<void>}} Native process boundary.
+ */
+export function startWindowsProcessJob(command) {
+  const directory = mkdtempSync(path.join(tmpdir(), "lisa-windows-job-"));
+  const powershell = path.join(
+    env.SystemRoot || "C:\\Windows",
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  );
+  const script = fileURLToPath(
+    new URL("./windows-process-job.ps1", import.meta.url)
+  );
+  let child;
+  try {
+    child = spawn(
+      powershell,
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-File", script],
+      {
+        // The native job supplies isolation. Keep the helper attached so
+        // Windows PowerShell retains the caller's standard handles.
+        stdio: "inherit",
+        env: {
+          ...env,
+          TEMP: directory,
+          TMP: directory,
+          LISA_WINDOWS_PROCESS_JOB: JSON.stringify({
+            command,
+            directory,
+            parentPid: process.pid,
+            cwd: process.cwd(),
+            originalTemp: env.TEMP ?? null,
+            originalTmp: env.TMP ?? null,
+          }),
+        },
+      }
+    );
+  } catch (error) {
+    rmSync(directory, { recursive: true, force: true });
+    throw error;
+  }
+  let closed = false;
+  const completion = new Promise(resolve => {
+    child.once("close", () => {
+      closed = true;
+      resolve();
+    });
+    child.once("error", () => {
+      if (child.pid === undefined)
+        rmSync(directory, { recursive: true, force: true });
+    });
+  });
+  const reap = async () => {
+    let timer;
+    try {
+      if (!closed) writeFileSync(path.join(directory, "stop"), "stop");
+      await Promise.race([
+        completion,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            // Killing the owner closes its job handle as a last resort, but
+            // cannot supply a completed wait: reject instead of claiming reap.
+            child.kill("SIGKILL");
+            reject(
+              new Error("Windows gate helper did not complete its cleanup wait")
+            );
+          }, CLEANUP_TIMEOUT_MS);
+        }),
+      ]);
+      if (readFileSync(path.join(directory, "reaped"), "utf8") !== "reaped") {
+        throw new Error("Windows gate helper did not confirm an empty job");
+      }
+    } catch (error) {
+      // A failed stop-file write must still close the job owner. Its native
+      // KILL_ON_JOB_CLOSE limit stops contained processes; the finally block
+      // waits for helper close before removing scratch. Keep this a failure:
+      // forced termination cannot provide the normal empty-job receipt.
+      if (!closed && !child.killed) child.kill("SIGKILL");
+      throw new Error(
+        `Windows gate cleanup was not verified (helper exit ${child.exitCode ?? child.signalCode ?? "pending"}): ${error.message}`
+      );
+    } finally {
+      clearTimeout(timer);
+      if (!closed) {
+        // Give a killed helper time to close before a CLI rejection exits Node.
+        // Still bound failure when the OS cannot stop the helper promptly.
+        await Promise.race([
+          completion,
+          new Promise(resolve => {
+            timer = setTimeout(resolve, 1000);
+          }),
+        ]);
+        clearTimeout(timer);
+      }
+      if (closed) rmSync(directory, { recursive: true, force: true });
+      else
+        child.once("close", () =>
+          rmSync(directory, { recursive: true, force: true })
+        );
+    }
+  };
+  return { child, reap };
+}

package/all/copy-overwrite/scripts/lib/windows-process-job.ps1

@@ -0,0 +1,25 @@
+# This file is managed by Lisa and IS replaced on each `lisa` run.
+# Do not edit directly — durable changes belong upstream in Lisa.
+# Use the installed Windows PowerShell policy; never override execution policy.
+$ErrorActionPreference = 'Stop'
+$parent = $null
+try {
+    $config = $env:LISA_WINDOWS_PROCESS_JOB | ConvertFrom-Json
+    Remove-Item Env:LISA_WINDOWS_PROCESS_JOB
+    $parent = [Diagnostics.Process]::GetProcessById([int]$config.parentPid)
+    $null = $parent.Handle
+    Add-Type -Path (Join-Path $PSScriptRoot 'windows-process-job.cs')
+    # Compiler scratch belongs to this helper; the gate retains its original env.
+    [Environment]::SetEnvironmentVariable('TEMP', $config.originalTemp)
+    [Environment]::SetEnvironmentVariable('TMP', $config.originalTmp)
+    [Environment]::CurrentDirectory = $config.cwd
+    $code = [LisaWindowsProcessJob]::Run($config.command, $config.directory, $parent)
+    # Only a completed native membership wait may authorize a successful reap.
+    [IO.File]::WriteAllText((Join-Path $config.directory 'reaped'), 'reaped')
+    exit $code
+} catch {
+    [Console]::Error.WriteLine('Windows gate containment failed: ' + $_.Exception.Message)
+    exit 1
+} finally {
+    if ($null -ne $parent) { $parent.Dispose() }
+}

package/dist/core/lisa-owned-hash-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA20CjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA8uCjC,CAAC"}
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAg2CjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAmwCjC,CAAC"}

package/dist/core/lisa-owned-hash-ledger.js

@@ -153,6 +153,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "4a5dce9c10d75b1027c9cc8606aba99cfd1fbcca3fa52f12a8a2433eac3e55bd",
         "5c666bc36267bb4008e074638be96856676957ff79e0506c7a6e073bce5319e6",
         "880f37a8cc95ed051d7cfbdd4560d3e01cc99b1b9d01631681cadf0e33d37bd2",
+        "99764b136eaa7bba3b7abf78f60bc6805f8c008a9cac59c78c5eadba35cecdc7",
         "9d570347fb1177be2381fe3f119882762be08a1a23c0a9486bdf5a6a97e02b5b",
         "b284a59b3ce5dfa8fa4e6b9c5789c6c9c08120eaf957a91453fc659322feab28",
         "b3c89213aab541483cf50c9c7ccbd4dd931fb5ef4d079e970ea82520f22bd01c",
@@ -472,7 +473,9 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "cffebe7feca1b5cce7b514bd1b5e991375cbc20607dff70385699e474e36b4d3",
         "d9ce218e754bf28a8d3d9b3b92c34ae9ce2e7b22182d31d9a87302ba33cc0151",
         "eb73088635fddf236fca92d1c94324a889c503843155d436835b96d3ed6fa1f1",
+        "f248672f91e4f1b7a604278762e1b6a037ea05356ff9ce70d31057ae3c257d83",
         "fb68902c68b4cd156f26d2f743364f611a54b833bc445b5144b4c844f553f188",
+        "fe045e89990248b735281275a736ab54861fdb003af3267cd1166c4f1489b91b",
     ]),
     "scripts/lib/reusable-workflow-load-adapter.d.mts": Object.freeze([
         "289c57b7cf1de7c2b5a2e89de8e706d53fc590592b8f3ba08ba41e04f97fd343",
@@ -501,6 +504,24 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "6203064d0403906016f6700b092551ff561b811fb9c02cbbdec59b85b0af81b0",
         "66fb27cc1de6baf48acf908715624c04b7738f831944a6c1c9daff50383026be",
     ]),
+    "scripts/lib/windows-process-job.cs": Object.freeze([
+        "198c23dfee840abaad516d84e70c943eca565baf13d54bc143c8e7f925be038c",
+        "7bbe3b13bfc35ca2a0b85fbee9a8f0a6549bf8b05997f6ce4b361bd09d924218",
+        "8de9cd7b38c7afd0b837de9baa4cb8d3ddceeb0a1b434862e2ad3549044a6790",
+        "bf32dc865bd16c03181df1564e2576ce308e952d21bc7a71571b2138532763f9",
+    ]),
+    "scripts/lib/windows-process-job.mjs": Object.freeze([
+        "109224c7c0d98447117f78a794a70df07925370a1ab01945bf0369f5bfe498b8",
+        "33fb198c1c5f32e6a615741eb21ee22a86d38701c6137bc00c72a273c2ad4b76",
+        "599628647c03ac22fe7cd5df22219a70b67e449cc893cc85564a93d658df2c2d",
+        "bc7cbab9ff259b4858c35b74803f962375277eb56b57d7b7cb05ddbd8aa73063",
+        "d7362a646468f87805b6d9e87fe61f2a2a97b4d481b31627a634edb66229f19d",
+        "e448bb4c092d6ae5c868352f355c78e6d8d549cdd6a12c505ca0a5923e0cae62",
+    ]),
+    "scripts/lib/windows-process-job.ps1": Object.freeze([
+        "5b978f201be9a035001f0cc4a7e8da76a67f26e6f99da91907747c4d65d58f1b",
+        "d73b15152703d7f195d1e06f7d7cee5437373237fcd74fe68afbd79fccebc1ba",
+    ]),
     "scripts/lib/worktree-dependencies.d.mts": Object.freeze([
         "66f77b767869f57185b819ca6f294ad0706348b50eba12f78af2430d9c8775df",
         "acc2b7a00f1e6f806359c6609e58743b6293f17f3a5ac30abd18b1a22fab8bfc",
@@ -1519,6 +1540,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "43558ba985967a3710e75361845afa987e84b17dbc264bb3ff68d8bfdf463318",
         "4a5dce9c10d75b1027c9cc8606aba99cfd1fbcca3fa52f12a8a2433eac3e55bd",
         "880f37a8cc95ed051d7cfbdd4560d3e01cc99b1b9d01631681cadf0e33d37bd2",
+        "99764b136eaa7bba3b7abf78f60bc6805f8c008a9cac59c78c5eadba35cecdc7",
         "9d570347fb1177be2381fe3f119882762be08a1a23c0a9486bdf5a6a97e02b5b",
         "b284a59b3ce5dfa8fa4e6b9c5789c6c9c08120eaf957a91453fc659322feab28",
         "b3c89213aab541483cf50c9c7ccbd4dd931fb5ef4d079e970ea82520f22bd01c",
@@ -1821,7 +1843,9 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "cffebe7feca1b5cce7b514bd1b5e991375cbc20607dff70385699e474e36b4d3",
         "d9ce218e754bf28a8d3d9b3b92c34ae9ce2e7b22182d31d9a87302ba33cc0151",
         "eb73088635fddf236fca92d1c94324a889c503843155d436835b96d3ed6fa1f1",
+        "f248672f91e4f1b7a604278762e1b6a037ea05356ff9ce70d31057ae3c257d83",
         "fb68902c68b4cd156f26d2f743364f611a54b833bc445b5144b4c844f553f188",
+        "fe045e89990248b735281275a736ab54861fdb003af3267cd1166c4f1489b91b",
     ]),
     "scripts/lib/reusable-workflow-load-adapter.d.mts": Object.freeze([
         "289c57b7cf1de7c2b5a2e89de8e706d53fc590592b8f3ba08ba41e04f97fd343",
@@ -1850,6 +1874,24 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "6203064d0403906016f6700b092551ff561b811fb9c02cbbdec59b85b0af81b0",
         "66fb27cc1de6baf48acf908715624c04b7738f831944a6c1c9daff50383026be",
     ]),
+    "scripts/lib/windows-process-job.cs": Object.freeze([
+        "198c23dfee840abaad516d84e70c943eca565baf13d54bc143c8e7f925be038c",
+        "7bbe3b13bfc35ca2a0b85fbee9a8f0a6549bf8b05997f6ce4b361bd09d924218",
+        "8de9cd7b38c7afd0b837de9baa4cb8d3ddceeb0a1b434862e2ad3549044a6790",
+        "bf32dc865bd16c03181df1564e2576ce308e952d21bc7a71571b2138532763f9",
+    ]),
+    "scripts/lib/windows-process-job.mjs": Object.freeze([
+        "109224c7c0d98447117f78a794a70df07925370a1ab01945bf0369f5bfe498b8",
+        "33fb198c1c5f32e6a615741eb21ee22a86d38701c6137bc00c72a273c2ad4b76",
+        "599628647c03ac22fe7cd5df22219a70b67e449cc893cc85564a93d658df2c2d",
+        "bc7cbab9ff259b4858c35b74803f962375277eb56b57d7b7cb05ddbd8aa73063",
+        "d7362a646468f87805b6d9e87fe61f2a2a97b4d481b31627a634edb66229f19d",
+        "e448bb4c092d6ae5c868352f355c78e6d8d549cdd6a12c505ca0a5923e0cae62",
+    ]),
+    "scripts/lib/windows-process-job.ps1": Object.freeze([
+        "5b978f201be9a035001f0cc4a7e8da76a67f26e6f99da91907747c4d65d58f1b",
+        "d73b15152703d7f195d1e06f7d7cee5437373237fcd74fe68afbd79fccebc1ba",
+    ]),
     "scripts/lib/worktree-dependencies.d.mts": Object.freeze([
         "66f77b767869f57185b819ca6f294ad0706348b50eba12f78af2430d9c8775df",
         "acc2b7a00f1e6f806359c6609e58743b6293f17f3a5ac30abd18b1a22fab8bfc",