@lesliechan721/agent-skill-eval 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/process-tree.js

@@ -1,12 +1,33 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
 const DEFAULT_PROCESS_MARKER_ENV = 'AW_NATIVE_CLI_PROCESS_MARKER';
 const PROCESS_TREE_COMMAND_TIMEOUT_MS = 1_000;
-const PROCESS_TREE_LOOKUP_TIMEOUT_MS = 250;
 const PROCESS_TREE_OBSERVATION_INTERVAL_MS = 50;
 const PROCESS_TREE_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 const observationStates = new WeakMap();
 const defaultExecFile = (command, args, options, callback) => execFile(command, args, options, (error, stdout) => callback(error, stdout));
-function runCommand(command, args, execFileImpl, timeoutMs) {
+function safeCommandFailureValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_.-]{1,64}$/u.test(value))
+        return undefined;
+    return value;
+}
+function commandFailure(reason, error) {
+    const details = error && typeof error === 'object'
+        ? error
+        : {};
+    const code = safeCommandFailureValue(details.code);
+    const signal = safeCommandFailureValue(details.signal);
+    return {
+        reason,
+        ...(code !== undefined ? { code } : {}),
+        ...(typeof signal === 'string' ? { signal } : {}),
+        ...(typeof details.killed === 'boolean' ? { killed: details.killed } : {}),
+    };
+}
+function runCommandWithDiagnostics(command, args, execFileImpl, timeoutMs) {
     return new Promise((resolve) => {
         let settled = false;
         const finish = (result) => {
@@ -16,30 +37,49 @@ function runCommand(command, args, execFileImpl, timeoutMs) {
             clearTimeout(timeout);
             resolve(result);
         };
-        const timeout = setTimeout(() => finish(null), timeoutMs);
+        const timeout = setTimeout(() => finish({
+            output: null,
+            failure: commandFailure('deadline-exceeded'),
+        }), timeoutMs);
         timeout.unref();
         try {
             execFileImpl(command, args, {
                 timeout: timeoutMs,
                 windowsHide: true,
                 maxBuffer: PROCESS_TREE_MAX_BUFFER_BYTES,
-            }, (error, stdout) => finish(error ? null : stdout));
+            }, (error, stdout) => finish(error
+                ? { output: null, failure: commandFailure('callback-error', error) }
+                : { output: stdout }));
         }
-        catch {
-            finish(null);
+        catch (error) {
+            finish({ output: null, failure: commandFailure('synchronous-error', error) });
         }
     });
 }
+function runCommand(command, args, execFileImpl, timeoutMs) {
+    return runCommandWithDiagnostics(command, args, execFileImpl, timeoutMs)
+        .then((result) => result.output);
+}
 function parsePosixProcessTable(stdout) {
     const table = new Map();
     for (const line of stdout.split('\n')) {
-        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/u.exec(line);
-        if (!match)
+        const groupMatch = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/u.exec(line);
+        if (groupMatch) {
+            table.set(Number(groupMatch[1]), {
+                ppid: Number(groupMatch[2]),
+                pgid: Number(groupMatch[3]),
+                state: groupMatch[4],
+                startTime: groupMatch[5],
+            });
             continue;
-        table.set(Number(match[1]), {
-            ppid: Number(match[2]),
-            state: match[3],
-            startTime: match[4],
+        }
+        const legacyMatch = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/u.exec(line);
+        if (!legacyMatch)
+            continue;
+        table.set(Number(legacyMatch[1]), {
+            ppid: Number(legacyMatch[2]),
+            state: legacyMatch[3],
+            startTime: legacyMatch[4],
         });
     }
     return table;
@@ -49,28 +89,147 @@ function parseMarkerProcessIds(stdout, markerEnvironmentVariable, marker) {
     const assignment = `${markerEnvironmentVariable}=${marker}`;
     for (const line of stdout.split('\n')) {
         const match = /^\s*(\d+)\s+(.+)$/u.exec(line);
-        if (match?.[2].includes(assignment))
+        if (match?.[2].split(/\s+/u).includes(assignment))
             processIds.add(Number(match[1]));
     }
     return processIds;
 }
-async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, marker, timeoutMs = PROCESS_TREE_LOOKUP_TIMEOUT_MS) {
-    const [identityOutput, markerOutput] = await Promise.all([
-        runCommand('ps', ['-A', '-o', 'pid=,ppid=,state=,lstart='], execFileImpl, timeoutMs),
+async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, marker, timeoutMs = PROCESS_TREE_COMMAND_TIMEOUT_MS, confirmUnmarkedPid) {
+    const identityArgs = ['-A', '-o', 'pid=,ppid=,pgid=,state=,lstart='];
+    const markerArgs = ['eww', '-A', '-o', 'pid=,command='];
+    const lookupStartedAt = Date.now();
+    const [identityOutput, initialMarkerResult] = await Promise.all([
+        runCommand('ps', identityArgs, execFileImpl, timeoutMs),
         marker === undefined
-            ? Promise.resolve('')
-            : runCommand('ps', ['eww', '-A', '-o', 'pid=,command='], execFileImpl, timeoutMs),
+            ? Promise.resolve({ output: '' })
+            : runCommandWithDiagnostics('ps', markerArgs, execFileImpl, timeoutMs),
     ]);
     if (identityOutput === null)
         return null;
+    let markerResult = initialMarkerResult;
+    let markerLookupAttempts = marker === undefined ? 0 : 1;
+    const retryTimeoutMs = timeoutMs - (Date.now() - lookupStartedAt);
+    if (marker !== undefined && markerResult.output === null && retryTimeoutMs > 0) {
+        markerLookupAttempts += 1;
+        markerResult = await runCommandWithDiagnostics('ps', markerArgs, execFileImpl, retryTimeoutMs);
+    }
+    const markerOutput = markerResult.output;
+    const table = parsePosixProcessTable(identityOutput);
+    const markerPids = marker === undefined || markerOutput === null
+        ? new Set()
+        : parseMarkerProcessIds(markerOutput, markerEnvironmentVariable, marker);
+    const confirmedUnmarkedPids = new Set();
+    const unmarkedEntry = confirmUnmarkedPid === undefined || markerPids.has(confirmUnmarkedPid)
+        ? undefined
+        : table.get(confirmUnmarkedPid);
+    if (unmarkedEntry && !unmarkedEntry.state?.startsWith('Z')) {
+        const confirmationOutput = await runCommand('ps', identityArgs, execFileImpl, timeoutMs);
+        if (confirmationOutput === null)
+            return null;
+        const confirmedEntry = parsePosixProcessTable(confirmationOutput).get(confirmUnmarkedPid);
+        if (confirmedEntry?.startTime === unmarkedEntry.startTime &&
+            !confirmedEntry.state?.startsWith('Z')) {
+            confirmedUnmarkedPids.add(confirmUnmarkedPid);
+        }
+    }
     return {
-        table: parsePosixProcessTable(identityOutput),
-        markerPids: marker === undefined || markerOutput === null
-            ? new Set()
-            : parseMarkerProcessIds(markerOutput, markerEnvironmentVariable, marker),
+        table,
+        markerPids,
         markerLookupSucceeded: marker === undefined || markerOutput !== null,
+        markerLookupAttempts,
+        ...(markerResult.failure ? { markerLookupFailure: markerResult.failure } : {}),
+        confirmedUnmarkedPids,
+    };
+}
+function posixMarkerLookupFailure(snapshot, stage) {
+    const fields = [
+        `stage=${stage}`,
+        `attempts=${snapshot.markerLookupAttempts}`,
+        `reason=${snapshot.markerLookupFailure?.reason ?? 'unknown'}`,
+    ];
+    if (snapshot.markerLookupFailure?.code !== undefined) {
+        fields.push(`code=${snapshot.markerLookupFailure.code}`);
+    }
+    if (snapshot.markerLookupFailure?.signal !== undefined) {
+        fields.push(`signal=${snapshot.markerLookupFailure.signal}`);
+    }
+    if (snapshot.markerLookupFailure?.killed !== undefined) {
+        fields.push(`killed=${snapshot.markerLookupFailure.killed}`);
+    }
+    return cleanupUnconfirmed(`POSIX process marker lookup failed (${fields.join(', ')}).`);
+}
+async function defaultCreateSentinel(markerEnvironmentVariable, marker) {
+    const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 60_000)'], {
+        env: { [markerEnvironmentVariable]: marker },
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    await once(child, 'spawn');
+    if (child.pid === undefined)
+        throw cleanupUnconfirmed('inspection sentinel did not start.');
+    return {
+        pid: child.pid,
+        stop: async () => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            const closed = once(child, 'close').then(() => undefined);
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                // The controlled sentinel can exit before release.
+            }
+            await closed;
+        },
     };
 }
+function validateLeaseSnapshot(snapshot, lease, stage) {
+    if (!snapshot.markerLookupSucceeded) {
+        return posixMarkerLookupFailure(snapshot, stage);
+    }
+    const sentinelEntry = snapshot.table.get(lease.sentinel.pid);
+    if (sentinelEntry?.startTime !== lease.sentinel.startTime ||
+        !snapshot.markerPids.has(lease.sentinel.pid)) {
+        return cleanupUnconfirmed('POSIX inspection sentinel could not be verified.');
+    }
+    return undefined;
+}
+export async function acquireProcessTreeInspectionLease(dependencies = {}) {
+    const platform = dependencies.platform ?? process.platform;
+    if (platform !== 'darwin' && platform !== 'linux') {
+        throw cleanupUnconfirmed(`process inspection is unsupported on ${platform}.`);
+    }
+    const markerEnvironmentVariable = dependencies.markerEnvironmentVariable ?? DEFAULT_PROCESS_MARKER_ENV;
+    const marker = randomUUID();
+    const sentinel = await (dependencies.createSentinel ?? defaultCreateSentinel)(markerEnvironmentVariable, marker);
+    try {
+        const snapshot = await readPosixProcessTable(dependencies.execFile ?? defaultExecFile, markerEnvironmentVariable, marker);
+        if (!snapshot)
+            throw cleanupUnconfirmed('POSIX process identity lookup failed.');
+        if (!snapshot.markerLookupSucceeded) {
+            throw posixMarkerLookupFailure(snapshot, 'inspection-preflight');
+        }
+        const entry = snapshot.table.get(sentinel.pid);
+        if (!entry || !snapshot.markerPids.has(sentinel.pid)) {
+            throw cleanupUnconfirmed('POSIX inspection sentinel could not be verified.');
+        }
+        let released = false;
+        return {
+            marker,
+            sentinel: { pid: sentinel.pid, startTime: entry.startTime },
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                await sentinel.stop();
+            },
+        };
+    }
+    catch (error) {
+        await sentinel.stop();
+        throw error;
+    }
+}
 function parseWindowsProcessTable(stdout) {
     const table = new Map();
     for (const line of stdout.split('\n')) {
@@ -128,6 +287,8 @@ function refreshObservedProcesses(state, table, markerPids = new Set(), allowRoo
     }
     state.rootDiscoveryPending = false;
     for (const processId of markerPids) {
+        if (processId === state.lease?.sentinel.pid)
+            continue;
         if (processId === state.root?.pid)
             continue;
         const entry = table.get(processId);
@@ -140,9 +301,111 @@ function refreshObservedProcesses(state, table, markerPids = new Set(), allowRoo
     }
     refreshDescendants(state.root, state.descendants, table);
 }
-function createProcessTreeObservation(pid, marker, dependencies, startLookup) {
+function latchObservationFailure(state, error) {
+    if (state.failure)
+        return;
+    state.failure = error;
+    for (const listener of state.failureListeners)
+        listener(error);
+}
+function acceptPosixSnapshot(state, snapshot, stage) {
+    if (!snapshot.markerLookupSucceeded && state.marker !== undefined) {
+        latchObservationFailure(state, posixMarkerLookupFailure(snapshot, stage));
+        return false;
+    }
+    if (state.lease) {
+        const leaseFailure = validateLeaseSnapshot(snapshot, state.lease, stage);
+        if (leaseFailure) {
+            latchObservationFailure(state, leaseFailure);
+            return false;
+        }
+    }
+    const rootEntry = snapshot.table.get(state.pid);
+    if (state.marker !== undefined &&
+        state.dependencies.enforceCooperativeProcessGroup === true &&
+        rootEntry !== undefined &&
+        !rootEntry.state?.startsWith('Z') &&
+        snapshot.confirmedUnmarkedPids.has(state.pid)) {
+        state.root = { pid: state.pid, startTime: rootEntry.startTime };
+        latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: a live provider process lost its process marker.'));
+    }
+    refreshObservedProcesses(state, snapshot.table, snapshot.markerPids);
+    if (state.marker !== undefined) {
+        const providerMarkerPids = [...snapshot.markerPids].filter((pid) => pid !== state.lease?.sentinel.pid);
+        if (state.dependencies.enforceCooperativeProcessGroup === true &&
+            state.rootPgidMode === undefined) {
+            if (state.root?.pid === state.pid &&
+                rootEntry?.startTime === state.root.startTime &&
+                rootEntry.pgid !== undefined &&
+                snapshot.markerPids.has(state.pid)) {
+                if (rootEntry.pgid === state.pid) {
+                    state.rootPgid = rootEntry.pgid;
+                    state.rootPgidMode = 'owned';
+                }
+                else {
+                    state.rootPgidMode = 'shared';
+                }
+            }
+            else if (rootEntry === undefined &&
+                (providerMarkerPids.some((pid) => snapshot.table.get(pid)?.pgid !== undefined) ||
+                    [...snapshot.table].some(([pid, entry]) => pid !== state.lease?.sentinel.pid &&
+                        entry.pgid === state.pid &&
+                        !entry.state?.startsWith('Z')))) {
+                state.rootPgid = state.pid;
+                state.rootPgidMode = 'missing';
+            }
+        }
+        const expectedPgid = state.rootPgidMode === 'owned'
+            ? state.rootPgid
+            : state.rootPgidMode === 'missing'
+                ? state.pid
+                : undefined;
+        if (expectedPgid !== undefined &&
+            providerMarkerPids.some((pid) => {
+                const entry = snapshot.table.get(pid);
+                return entry?.pgid !== undefined && entry.pgid !== expectedPgid;
+            })) {
+            latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: a marked process left its initial process group.'));
+        }
+        const liveKnownIdentities = [state.root, ...state.descendants.values()].filter((identity) => identityMatches(identity, snapshot.table) &&
+            !snapshot.table.get(identity.pid)?.state?.startsWith('Z'));
+        const markerlessKnownIdentity = state.dependencies.enforceCooperativeProcessGroup === true &&
+            liveKnownIdentities.some((identity) => identity.pid !== state.pid && !snapshot.markerPids.has(identity.pid));
+        let markerlessInitialGroupMember = false;
+        if (state.rootPgid !== undefined) {
+            for (const [pid, entry] of snapshot.table) {
+                if (entry.pgid !== state.rootPgid || entry.state?.startsWith('Z'))
+                    continue;
+                if (pid !== state.root?.pid) {
+                    const known = state.descendants.get(pid);
+                    if (!known || known.startTime === entry.startTime) {
+                        state.descendants.set(pid, { pid, startTime: entry.startTime });
+                    }
+                }
+                if (pid !== state.pid && !snapshot.markerPids.has(pid)) {
+                    markerlessInitialGroupMember = true;
+                }
+            }
+        }
+        if (markerlessKnownIdentity || markerlessInitialGroupMember) {
+            latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: a live provider process lost its process marker.'));
+        }
+    }
+    state.lastSnapshot = snapshot;
+    return true;
+}
+function createProcessTreeObservation(pid, marker, dependencies, startLookup, lease) {
     const observation = {
         pid,
+        onFailure: (listener) => {
+            const state = observationStates.get(observation);
+            if (!state)
+                return () => undefined;
+            state.failureListeners.add(listener);
+            if (state.failure)
+                listener(state.failure);
+            return () => state.failureListeners.delete(listener);
+        },
         dispose: () => {
             const state = observationStates.get(observation);
             if (state) {
@@ -157,9 +420,11 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup) {
         platform: dependencies.platform ?? process.platform,
         marker,
         markerEnvironmentVariable: dependencies.markerEnvironmentVariable ?? DEFAULT_PROCESS_MARKER_ENV,
+        lease,
         dependencies,
         rootDiscoveryPending: true,
         descendants: new Map(),
+        failureListeners: new Set(),
         disposed: false,
         initialLookup: Promise.resolve(),
     };
@@ -172,10 +437,16 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup) {
             if (!state.disposed && table)
                 refreshObservedProcesses(state, table);
         })
-        : readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, marker).then((snapshot) => {
-            if (!state.disposed && snapshot) {
-                refreshObservedProcesses(state, snapshot.table, snapshot.markerPids, !snapshot.markerLookupSucceeded);
+        : readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, marker, PROCESS_TREE_COMMAND_TIMEOUT_MS, dependencies.enforceCooperativeProcessGroup === true && marker !== undefined
+            ? state.pid
+            : undefined).then((snapshot) => {
+            if (state.disposed)
+                return;
+            if (!snapshot) {
+                latchObservationFailure(state, cleanupUnconfirmed('POSIX process identity lookup failed.'));
+                return;
             }
+            acceptPosixSnapshot(state, snapshot, 'observation');
         });
     const scheduleRefresh = () => {
         if (state.disposed)
@@ -191,24 +462,12 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup) {
         void state.initialLookup.finally(scheduleRefresh);
     return observation;
 }
-export function observeProcessTree(pid, marker, dependencies = {}) {
-    return createProcessTreeObservation(pid, marker, dependencies, true);
+export function observeProcessTree(pid, marker, dependencies = {}, lease) {
+    return createProcessTreeObservation(pid, marker, dependencies, true, lease);
 }
 export async function assertProcessTreeInspectionAvailable(dependencies = {}) {
-    const platform = dependencies.platform ?? process.platform;
-    const execFileImpl = dependencies.execFile ?? defaultExecFile;
-    if (platform === 'win32') {
-        if (!(await readWindowsProcessTable(execFileImpl))) {
-            throw cleanupUnconfirmed('Windows process identity lookup failed.');
-        }
-        return;
-    }
-    const snapshot = await readPosixProcessTable(execFileImpl, dependencies.markerEnvironmentVariable ?? DEFAULT_PROCESS_MARKER_ENV, 'preflight-marker');
-    if (!snapshot)
-        throw cleanupUnconfirmed('POSIX process identity lookup failed.');
-    if (!snapshot.markerLookupSucceeded) {
-        throw cleanupUnconfirmed('POSIX process marker lookup failed.');
-    }
+    const lease = await acquireProcessTreeInspectionLease(dependencies);
+    await lease.release();
 }
 function cleanupUnconfirmed(detail) {
     return new Error(`Process tree cleanup unconfirmed: ${detail}`);
@@ -229,6 +488,42 @@ function signalIdentity(identity, snapshot, signal, kill) {
         // The process can exit between identity verification and the signal.
     }
 }
+function safelyOwnedProcessGroup(state, snapshot) {
+    if (state.dependencies.enforceCooperativeProcessGroup !== true ||
+        state.marker === undefined ||
+        state.rootPgid === undefined ||
+        state.rootPgid !== state.pid)
+        return undefined;
+    const pgid = state.rootPgid;
+    const members = [...snapshot.table].filter(([, entry]) => entry.pgid === pgid && !entry.state?.startsWith('Z'));
+    if (members.length === 0)
+        return undefined;
+    const known = [state.root, ...state.descendants.values()];
+    if (members.some(([pid, entry]) => !known.some((identity) => identity?.pid === pid && identity.startTime === entry.startTime)))
+        return undefined;
+    return pgid;
+}
+function signalProcessGroup(pgid, signal, kill) {
+    if (pgid === undefined)
+        return;
+    try {
+        kill(-pgid, signal);
+    }
+    catch {
+        // The verified process group can exit before the signal.
+    }
+}
+function latchLiveDescendantCompletionFailure(state, snapshot) {
+    if (state.dependencies.enforceCooperativeProcessGroup !== true)
+        return;
+    const liveDescendant = [...state.descendants.values()].some((identity) => identity.pid !== state.pid &&
+        identity.pid !== state.lease?.sentinel.pid &&
+        posixIdentityMatches(identity, snapshot) &&
+        !snapshot.table.get(identity.pid)?.state?.startsWith('Z'));
+    if (!liveDescendant)
+        return;
+    latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: all provider descendants must exit before completion.'));
+}
 async function runTaskkill(pid, execFileImpl) {
     return (await runCommand('taskkill', ['/PID', String(pid), '/T', '/F'], execFileImpl, PROCESS_TREE_COMMAND_TIMEOUT_MS)) !== null;
 }
@@ -267,42 +562,61 @@ async function terminateWindowsProcessTree(state, requireConfirmedCleanup) {
         throw cleanupUnconfirmed('no inherited-pipe process identity was observed.');
     }
 }
-async function terminatePosixProcessTree(state, requireConfirmedCleanup, allowInspectionUnavailable) {
+async function terminatePosixProcessTree(state, requireConfirmedCleanup, allowInspectionUnavailable, requireDescendantsExitedBeforeCompletion) {
     await state.initialLookup;
+    state.disposed = true;
+    if (state.pollTimer)
+        clearTimeout(state.pollTimer);
     const execFileImpl = state.dependencies.execFile ?? defaultExecFile;
     const kill = state.dependencies.kill ?? process.kill.bind(process);
     const deadline = Date.now() + PROCESS_TREE_COMMAND_TIMEOUT_MS;
-    let snapshot = await readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, state.marker);
+    const inspect = async (timeoutMs, stage) => {
+        const next = await readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, state.marker, timeoutMs, state.dependencies.enforceCooperativeProcessGroup === true && state.marker !== undefined
+            ? state.pid
+            : undefined);
+        if (!next) {
+            latchObservationFailure(state, cleanupUnconfirmed('POSIX process identity lookup failed.'));
+            return undefined;
+        }
+        return acceptPosixSnapshot(state, next, stage) ? next : undefined;
+    };
+    let snapshot = await inspect(PROCESS_TREE_COMMAND_TIMEOUT_MS, 'termination-start');
+    let processGroupCurrentlyVerified = snapshot !== undefined;
+    if (!snapshot)
+        snapshot = state.lastSnapshot;
     if (!snapshot) {
         if (!requireConfirmedCleanup && allowInspectionUnavailable)
             return;
-        throw cleanupUnconfirmed('POSIX process identity lookup failed.');
+        throw state.failure ?? cleanupUnconfirmed('POSIX process identity lookup failed.');
     }
-    if (state.marker !== undefined && !snapshot.markerLookupSucceeded) {
-        throw cleanupUnconfirmed('POSIX process marker lookup failed.');
+    if (!processGroupCurrentlyVerified && safelyOwnedProcessGroup(state, snapshot) === undefined) {
+        if (!requireConfirmedCleanup && allowInspectionUnavailable)
+            return;
+        throw state.failure ?? cleanupUnconfirmed('POSIX process identity lookup failed.');
+    }
+    if (requireDescendantsExitedBeforeCompletion) {
+        latchLiveDescendantCompletionFailure(state, snapshot);
     }
-    let markerLookupEverFailed = state.marker !== undefined && !snapshot.markerLookupSucceeded;
-    refreshObservedProcesses(state, snapshot.table, snapshot.markerPids);
     const observedAtTermination = new Set([...state.descendants.values()]
         .filter((identity) => posixIdentityMatches(identity, snapshot))
         .map((identity) => `${identity.pid}:${identity.startTime}`));
     while (Date.now() < deadline) {
+        signalProcessGroup(processGroupCurrentlyVerified ? safelyOwnedProcessGroup(state, snapshot) : undefined, 'SIGSTOP', kill);
         if (posixIdentityMatches(state.root, snapshot)) {
             signalIdentity(state.root, snapshot, 'SIGSTOP', kill);
         }
         for (const identity of [...state.descendants.values()].reverse()) {
             signalIdentity(identity, snapshot, 'SIGSTOP', kill);
         }
-        const next = await readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, state.marker, Math.min(PROCESS_TREE_LOOKUP_TIMEOUT_MS, Math.max(1, deadline - Date.now())));
-        if (!next)
-            break;
-        markerLookupEverFailed ||=
-            state.marker !== undefined && !next.markerLookupSucceeded;
-        if (markerLookupEverFailed)
+        const next = await inspect(Math.max(1, deadline - Date.now()), 'termination-freeze');
+        if (!next) {
+            processGroupCurrentlyVerified = false;
             break;
+        }
         snapshot = next;
+        processGroupCurrentlyVerified = true;
         const previousSize = state.descendants.size;
-        refreshObservedProcesses(state, snapshot.table, snapshot.markerPids);
+        signalProcessGroup(safelyOwnedProcessGroup(state, snapshot), 'SIGSTOP', kill);
         if (posixIdentityMatches(state.root, snapshot)) {
             signalIdentity(state.root, snapshot, 'SIGSTOP', kill);
         }
@@ -320,42 +634,42 @@ async function terminatePosixProcessTree(state, requireConfirmedCleanup, allowIn
     }
     const killed = [state.root, ...state.descendants.values()].filter((identity) => identity !== undefined &&
         posixIdentityMatches(identity, snapshot));
+    const ownedPgid = processGroupCurrentlyVerified
+        ? safelyOwnedProcessGroup(state, snapshot)
+        : undefined;
     for (const identity of killed.reverse()) {
         signalIdentity(identity, snapshot, 'SIGKILL', kill);
     }
-    if (markerLookupEverFailed) {
-        throw cleanupUnconfirmed('POSIX process marker lookup failed.');
-    }
-    if (!requireConfirmedCleanup)
+    signalProcessGroup(ownedPgid, 'SIGKILL', kill);
+    if (!requireConfirmedCleanup) {
+        if (state.failure)
+            throw state.failure;
         return;
-    const verified = await readPosixProcessTable(execFileImpl, state.markerEnvironmentVariable, state.marker);
-    if (!verified)
-        throw cleanupUnconfirmed('POSIX termination verification failed.');
-    if (!verified.markerLookupSucceeded) {
-        throw cleanupUnconfirmed('POSIX process marker verification failed.');
+    }
+    const verified = await inspect(PROCESS_TREE_COMMAND_TIMEOUT_MS, 'termination-verification');
+    if (!verified) {
+        throw state.failure ?? cleanupUnconfirmed('POSIX termination verification failed.');
     }
     const stillRunning = killed.some((identity) => {
         if (!posixIdentityMatches(identity, verified))
             return false;
         return !verified.table.get(identity.pid)?.state?.startsWith('Z');
     });
-    if (stillRunning)
-        throw cleanupUnconfirmed('a verified POSIX descendant is still running.');
+    if (stillRunning) {
+        throw state.failure ?? cleanupUnconfirmed('a verified POSIX descendant is still running.');
+    }
     const unobservedMarkedProcess = state.marker === undefined
         ? false
-        : [...verified.markerPids].some((pid) => !verified.table.get(pid)?.state?.startsWith('Z'));
+        : [...verified.markerPids].some((pid) => pid !== state.lease?.sentinel.pid &&
+            !verified.table.get(pid)?.state?.startsWith('Z'));
     if (unobservedMarkedProcess) {
-        throw cleanupUnconfirmed('an unverified marker process is still running.');
-    }
-    if (requireConfirmedCleanup &&
-        state.marker !== undefined &&
-        state.root === undefined &&
-        state.descendants.size === 0) {
-        throw cleanupUnconfirmed('no marked process identity was observed.');
+        throw state.failure ?? cleanupUnconfirmed('an unverified marker process is still running.');
     }
     if (requireConfirmedCleanup && state.marker === undefined && observedAtTermination.size === 0) {
         throw cleanupUnconfirmed('no inherited-pipe process identity was observed.');
     }
+    if (state.failure)
+        throw state.failure;
 }
 export async function terminateProcessTree(pid, killDirectChild, dependencies = {}, options = {}) {
     const platform = dependencies.platform ?? process.platform;
@@ -370,7 +684,7 @@ export async function terminateProcessTree(pid, killDirectChild, dependencies =
             await terminateWindowsProcessTree(state, options.requireConfirmedCleanup ?? false);
             return;
         }
-        await terminatePosixProcessTree(state, options.requireConfirmedCleanup ?? false, options.allowInspectionUnavailable ?? false);
+        await terminatePosixProcessTree(state, options.requireConfirmedCleanup ?? false, options.allowInspectionUnavailable ?? false, options.requireDescendantsExitedBeforeCompletion ?? false);
     }
     finally {
         observation.dispose();