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

package/dist/process-tree.js

@@ -3,9 +3,14 @@ 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_OBSERVATION_INTERVAL_MS = 50;
+const POSIX_PROCESS_TREE_COMMAND_TIMEOUT_MS = 2_000;
+const PROCESS_TREE_IDENTITY_INTERVAL_MS = 250;
+const PROCESS_TREE_MARKER_INTERVAL_MS = 1_000;
+const PROCESS_TREE_TERMINATION_GRACE_MS = 250;
+const PROCESS_TREE_TERMINATION_SETTLE_MS = 50;
 const PROCESS_TREE_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 const observationStates = new WeakMap();
+const posixSamplers = new WeakMap();
 const defaultExecFile = (command, args, options, callback) => execFile(command, args, options, (error, stdout) => callback(error, stdout));
 function safeCommandFailureValue(value) {
     if (typeof value === 'number' && Number.isFinite(value))
@@ -84,27 +89,46 @@ function parsePosixProcessTable(stdout) {
     }
     return table;
 }
-function parseMarkerProcessIds(stdout, markerEnvironmentVariable, marker) {
+function parsePosixMarkerScan(stdout) {
+    const table = new Map();
+    const commands = new Map();
+    for (const line of stdout.split('\n')) {
+        const actual = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S{3}\s+\S{3}\s+\d+\s+\S+\s+\d{4})\s+(.*)$/u.exec(line);
+        const synthetic = actual ??
+            /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(.*)$/u.exec(line);
+        if (!synthetic)
+            continue;
+        const pid = Number(synthetic[1]);
+        table.set(pid, {
+            ppid: Number(synthetic[2]),
+            pgid: Number(synthetic[3]),
+            state: synthetic[4],
+            startTime: synthetic[5].replace(/\s+/gu, ' '),
+        });
+        commands.set(pid, synthetic[6]);
+    }
+    return { table, commands };
+}
+function parseMarkerProcessIds(scan, markerEnvironmentVariable, marker) {
     const processIds = new Set();
     const assignment = `${markerEnvironmentVariable}=${marker}`;
-    for (const line of stdout.split('\n')) {
-        const match = /^\s*(\d+)\s+(.+)$/u.exec(line);
-        if (match?.[2].split(/\s+/u).includes(assignment))
-            processIds.add(Number(match[1]));
+    for (const [pid, command] of scan.commands) {
+        if (command.split(/\s+/u).includes(assignment))
+            processIds.add(pid);
     }
     return processIds;
 }
-async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, marker, timeoutMs = PROCESS_TREE_COMMAND_TIMEOUT_MS, confirmUnmarkedPid) {
+async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, marker, timeoutMs = POSIX_PROCESS_TREE_COMMAND_TIMEOUT_MS, confirmUnmarkedPid) {
     const identityArgs = ['-A', '-o', 'pid=,ppid=,pgid=,state=,lstart='];
-    const markerArgs = ['eww', '-A', '-o', 'pid=,command='];
+    const markerArgs = ['eww', '-A', '-o', 'pid=,ppid=,pgid=,state=,lstart=,command='];
     const lookupStartedAt = Date.now();
-    const [identityOutput, initialMarkerResult] = await Promise.all([
-        runCommand('ps', identityArgs, execFileImpl, timeoutMs),
+    const [identityResult, initialMarkerResult] = await Promise.all([
+        runCommandWithDiagnostics('ps', identityArgs, execFileImpl, timeoutMs),
         marker === undefined
             ? Promise.resolve({ output: '' })
             : runCommandWithDiagnostics('ps', markerArgs, execFileImpl, timeoutMs),
     ]);
-    if (identityOutput === null)
+    if (identityResult.output === null)
         return null;
     let markerResult = initialMarkerResult;
     let markerLookupAttempts = marker === undefined ? 0 : 1;
@@ -114,20 +138,23 @@ async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, ma
         markerResult = await runCommandWithDiagnostics('ps', markerArgs, execFileImpl, retryTimeoutMs);
     }
     const markerOutput = markerResult.output;
-    const table = parsePosixProcessTable(identityOutput);
-    const markerPids = marker === undefined || markerOutput === null
+    const markerScan = markerOutput === null ? undefined : parsePosixMarkerScan(markerOutput);
+    const table = markerScan?.table ?? parsePosixProcessTable(identityResult.output);
+    const markerPids = marker === undefined || !markerScan
         ? new Set()
-        : parseMarkerProcessIds(markerOutput, markerEnvironmentVariable, marker);
+        : parseMarkerProcessIds(markerScan, 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);
+        const confirmationOutput = await runCommand('ps', markerArgs, execFileImpl, timeoutMs);
         if (confirmationOutput === null)
             return null;
-        const confirmedEntry = parsePosixProcessTable(confirmationOutput).get(confirmUnmarkedPid);
+        const confirmationScan = parsePosixMarkerScan(confirmationOutput);
+        const confirmedEntry = confirmationScan.table.get(confirmUnmarkedPid);
         if (confirmedEntry?.startTime === unmarkedEntry.startTime &&
+            !parseMarkerProcessIds(confirmationScan, markerEnvironmentVariable, marker).has(confirmUnmarkedPid) &&
             !confirmedEntry.state?.startsWith('Z')) {
             confirmedUnmarkedPids.add(confirmUnmarkedPid);
         }
@@ -141,6 +168,12 @@ async function readPosixProcessTable(execFileImpl, markerEnvironmentVariable, ma
         confirmedUnmarkedPids,
     };
 }
+function readPosixIdentityTable(execFileImpl) {
+    return runCommandWithDiagnostics('ps', ['-A', '-o', 'pid=,ppid=,pgid=,state=,lstart='], execFileImpl, POSIX_PROCESS_TREE_COMMAND_TIMEOUT_MS);
+}
+function readPosixMarkerOutput(execFileImpl) {
+    return runCommandWithDiagnostics('ps', ['eww', '-A', '-o', 'pid=,ppid=,pgid=,state=,lstart=,command='], execFileImpl, POSIX_PROCESS_TREE_COMMAND_TIMEOUT_MS);
+}
 function posixMarkerLookupFailure(snapshot, stage) {
     const fields = [
         `stage=${stage}`,
@@ -236,9 +269,12 @@ function parseWindowsProcessTable(stdout) {
         const match = /^\s*(\d+)\|(\d+)\|(.+?)\s*$/u.exec(line);
         if (!match)
             continue;
+        const startTime = match[3];
+        const creationTime = /^\d+$/u.test(startTime) ? BigInt(startTime) : undefined;
         table.set(Number(match[1]), {
             ppid: Number(match[2]),
-            startTime: match[3],
+            startTime,
+            ...(creationTime !== undefined ? { creationTime } : {}),
         });
     }
     return table;
@@ -251,7 +287,62 @@ function readWindowsProcessTable(execFileImpl) {
     ].join(' ');
     return runCommand('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], execFileImpl, PROCESS_TREE_COMMAND_TIMEOUT_MS).then((stdout) => stdout === null ? null : parseWindowsProcessTable(stdout));
 }
-function refreshDescendants(root, knownDescendants, table) {
+function collectDescendantProcessIds(rootPid, table) {
+    const childrenByParent = new Map();
+    for (const [processId, entry] of table) {
+        const children = childrenByParent.get(entry.ppid) ?? [];
+        children.push(processId);
+        childrenByParent.set(entry.ppid, children);
+    }
+    const descendants = new Set();
+    const visited = new Set([rootPid]);
+    const pending = [rootPid];
+    while (pending.length > 0) {
+        const parent = pending.shift();
+        for (const childPid of childrenByParent.get(parent) ?? []) {
+            if (visited.has(childPid))
+                continue;
+            visited.add(childPid);
+            descendants.add(childPid);
+            pending.push(childPid);
+        }
+    }
+    return descendants;
+}
+function collectComparableWindowsDescendantProcessIds(root, table) {
+    if (root?.creationTime === undefined)
+        return new Set();
+    const childrenByParent = new Map();
+    for (const [processId, entry] of table) {
+        const children = childrenByParent.get(entry.ppid) ?? [];
+        children.push(processId);
+        childrenByParent.set(entry.ppid, children);
+    }
+    const descendants = new Set();
+    const visited = new Set([root.pid]);
+    const pending = [root];
+    while (pending.length > 0) {
+        const parent = pending.shift();
+        for (const childPid of childrenByParent.get(parent.pid) ?? []) {
+            if (visited.has(childPid))
+                continue;
+            visited.add(childPid);
+            const entry = table.get(childPid);
+            if (entry.creationTime === undefined ||
+                parent.creationTime === undefined ||
+                entry.creationTime < parent.creationTime)
+                continue;
+            descendants.add(childPid);
+            pending.push({
+                pid: childPid,
+                startTime: entry.startTime,
+                creationTime: entry.creationTime,
+            });
+        }
+    }
+    return descendants;
+}
+function refreshDescendants(root, knownDescendants, table, requireComparableCreationOrder = false) {
     const childrenByParent = new Map();
     for (const [processId, entry] of table) {
         const children = childrenByParent.get(entry.ppid) ?? [];
@@ -259,20 +350,30 @@ function refreshDescendants(root, knownDescendants, table) {
         childrenByParent.set(entry.ppid, children);
     }
     const roots = [root, ...knownDescendants.values()].filter((identity) => identity !== undefined && table.get(identity.pid)?.startTime === identity.startTime);
-    const pending = roots.map((identity) => identity.pid);
-    const visited = new Set(pending);
+    const pending = [...roots];
+    const visited = new Set(pending.map((identity) => identity.pid));
     while (pending.length > 0) {
         const parent = pending.shift();
-        for (const descendantPid of childrenByParent.get(parent) ?? []) {
+        for (const descendantPid of childrenByParent.get(parent.pid) ?? []) {
             if (visited.has(descendantPid))
                 continue;
             visited.add(descendantPid);
             const entry = table.get(descendantPid);
+            if (requireComparableCreationOrder &&
+                (parent.creationTime === undefined ||
+                    entry.creationTime === undefined ||
+                    entry.creationTime < parent.creationTime))
+                continue;
             const knownIdentity = knownDescendants.get(descendantPid);
             if (knownIdentity && knownIdentity.startTime !== entry.startTime)
                 continue;
-            knownDescendants.set(descendantPid, { pid: descendantPid, startTime: entry.startTime });
-            pending.push(descendantPid);
+            const identity = {
+                pid: descendantPid,
+                startTime: entry.startTime,
+                ...(entry.creationTime !== undefined ? { creationTime: entry.creationTime } : {}),
+            };
+            knownDescendants.set(descendantPid, identity);
+            pending.push(identity);
         }
     }
 }
@@ -282,8 +383,13 @@ function refreshObservedProcesses(state, table, markerPids = new Set(), allowRoo
             allowRootWithoutMarker ||
             (state.rootDiscoveryPending && (state.platform === 'win32' || state.marker === undefined)))) {
         const entry = table.get(state.pid);
-        if (entry)
-            state.root = { pid: state.pid, startTime: entry.startTime };
+        if (entry && (state.platform !== 'win32' || entry.creationTime !== undefined)) {
+            state.root = {
+                pid: state.pid,
+                startTime: entry.startTime,
+                ...(entry.creationTime !== undefined ? { creationTime: entry.creationTime } : {}),
+            };
+        }
     }
     state.rootDiscoveryPending = false;
     for (const processId of markerPids) {
@@ -294,12 +400,20 @@ function refreshObservedProcesses(state, table, markerPids = new Set(), allowRoo
         const entry = table.get(processId);
         if (!entry)
             continue;
+        if (state.platform === 'win32' && entry.creationTime === undefined)
+            continue;
         const known = state.descendants.get(processId);
         if (!known || known.startTime === entry.startTime) {
-            state.descendants.set(processId, { pid: processId, startTime: entry.startTime });
+            state.descendants.set(processId, {
+                pid: processId,
+                startTime: entry.startTime,
+                ...(entry.creationTime !== undefined ? { creationTime: entry.creationTime } : {}),
+            });
         }
     }
-    refreshDescendants(state.root, state.descendants, table);
+    if (state.platform === 'win32' || state.marker === undefined) {
+        refreshDescendants(state.root, state.descendants, table, state.platform === 'win32');
+    }
 }
 function latchObservationFailure(state, error) {
     if (state.failure)
@@ -321,19 +435,30 @@ function acceptPosixSnapshot(state, snapshot, stage) {
         }
     }
     const rootEntry = snapshot.table.get(state.pid);
+    let confirmedUnmarkedRoot = snapshot.confirmedUnmarkedPids.has(state.pid);
+    if (state.marker !== undefined &&
+        rootEntry !== undefined &&
+        !rootEntry.state?.startsWith('Z') &&
+        (state.root === undefined || state.root.startTime === rootEntry.startTime) &&
+        !snapshot.markerPids.has(state.pid)) {
+        confirmedUnmarkedRoot ||=
+            state.unmarkedRootCandidate?.startTime === rootEntry.startTime;
+        state.unmarkedRootCandidate = { pid: state.pid, startTime: rootEntry.startTime };
+    }
+    else {
+        state.unmarkedRootCandidate = undefined;
+    }
     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 };
+        confirmedUnmarkedRoot) {
         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.rootPgidMode === undefined) {
             if (state.root?.pid === state.pid &&
                 rootEntry?.startTime === state.root.startTime &&
                 rootEntry.pgid !== undefined &&
@@ -344,6 +469,9 @@ function acceptPosixSnapshot(state, snapshot, stage) {
                 }
                 else {
                     state.rootPgidMode = 'shared';
+                    if (state.dependencies.enforceCooperativeProcessGroup === true) {
+                        latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: the provider root left its initial process group.'));
+                    }
                 }
             }
             else if (rootEntry === undefined &&
@@ -360,7 +488,8 @@ function acceptPosixSnapshot(state, snapshot, stage) {
             : state.rootPgidMode === 'missing'
                 ? state.pid
                 : undefined;
-        if (expectedPgid !== undefined &&
+        if (state.dependencies.enforceCooperativeProcessGroup === true &&
+            expectedPgid !== undefined &&
             providerMarkerPids.some((pid) => {
                 const entry = snapshot.table.get(pid);
                 return entry?.pgid !== undefined && entry.pgid !== expectedPgid;
@@ -369,31 +498,215 @@ function acceptPosixSnapshot(state, snapshot, stage) {
         }
         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));
+        const markerlessKnownIdentity = liveKnownIdentities.some((identity) => !snapshot.markerPids.has(identity.pid));
         let markerlessInitialGroupMember = false;
-        if (state.rootPgid !== undefined) {
+        const groupLeader = state.rootPgid === undefined
+            ? undefined
+            : snapshot.table.get(state.rootPgid);
+        const groupLeaderWasReused = state.rootPgidMode === 'owned' &&
+            groupLeader !== undefined &&
+            groupLeader.startTime !== state.root?.startTime;
+        if (state.rootPgid !== undefined && !groupLeaderWasReused) {
             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) {
+        if (state.dependencies.enforceCooperativeProcessGroup === true &&
+            (markerlessKnownIdentity || markerlessInitialGroupMember)) {
             latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: a live provider process lost its process marker.'));
         }
     }
-    state.lastSnapshot = snapshot;
     return true;
 }
+function getPosixProcessSampler(execFileImpl) {
+    const existing = posixSamplers.get(execFileImpl);
+    if (existing)
+        return existing;
+    const sampler = {
+        execFile: execFileImpl,
+        states: new Set(),
+        identityScannedAt: Number.NEGATIVE_INFINITY,
+        markerScannedAt: Number.NEGATIVE_INFINITY,
+    };
+    posixSamplers.set(execFileImpl, sampler);
+    return sampler;
+}
+function snapshotFromSampler(state, sampler) {
+    const markerLookupSucceeded = state.marker === undefined || sampler.markerFailure === undefined;
+    const table = state.marker === undefined || !markerLookupSucceeded
+        ? sampler.identityTable
+        : sampler.markerScan?.table;
+    if (!table)
+        return undefined;
+    const markerPids = state.marker === undefined || !markerLookupSucceeded || sampler.markerScan === undefined
+        ? new Set()
+        : parseMarkerProcessIds(sampler.markerScan, state.markerEnvironmentVariable, state.marker);
+    return {
+        table,
+        markerPids,
+        markerLookupSucceeded,
+        markerLookupAttempts: state.marker === undefined ? 0 : 1,
+        ...(sampler.markerFailure ? { markerLookupFailure: sampler.markerFailure } : {}),
+        confirmedUnmarkedPids: new Set(),
+    };
+}
+function deliverSamplerIdentity(sampler) {
+    for (const state of sampler.states) {
+        if (state.disposed)
+            continue;
+        if (sampler.identityFailure) {
+            latchObservationFailure(state, cleanupUnconfirmed('POSIX process identity lookup failed.'));
+            continue;
+        }
+        if (state.marker !== undefined) {
+            if (sampler.identityTable) {
+                refreshDescendants(state.root, state.descendants, sampler.identityTable);
+            }
+            const expectedPgid = state.rootPgidMode === 'owned'
+                ? state.rootPgid
+                : state.rootPgidMode === 'missing'
+                    ? state.pid
+                    : undefined;
+            if (state.dependencies.enforceCooperativeProcessGroup === true &&
+                expectedPgid !== undefined &&
+                [state.root, ...state.descendants.values()].some((identity) => {
+                    if (!identity || !sampler.identityTable)
+                        return false;
+                    const entry = sampler.identityTable.get(identity.pid);
+                    return entry?.startTime === identity.startTime &&
+                        entry.pgid !== undefined && entry.pgid !== expectedPgid;
+                })) {
+                latchObservationFailure(state, cleanupUnconfirmed('custom process contract violation: a marked process left its initial process group.'));
+            }
+            continue;
+        }
+        const snapshot = snapshotFromSampler(state, sampler);
+        if (snapshot)
+            acceptPosixSnapshot(state, snapshot, 'observation');
+    }
+}
+function deliverSamplerMarkers(sampler, stage) {
+    for (const state of sampler.states) {
+        if (state.disposed || state.marker === undefined)
+            continue;
+        const snapshot = snapshotFromSampler(state, sampler);
+        if (snapshot)
+            acceptPosixSnapshot(state, snapshot, stage);
+    }
+}
+function scanSamplerIdentity(sampler, force) {
+    if (sampler.identityInFlight)
+        return sampler.identityInFlight;
+    const now = Date.now();
+    if (!force &&
+        Number.isFinite(sampler.identityScannedAt) &&
+        now - sampler.identityScannedAt < PROCESS_TREE_IDENTITY_INTERVAL_MS)
+        return Promise.resolve();
+    sampler.identityScannedAt = now;
+    sampler.identityInFlight = readPosixIdentityTable(sampler.execFile)
+        .then((result) => {
+        sampler.identityFailure = result.failure;
+        sampler.identityTable = result.output === null
+            ? undefined
+            : parsePosixProcessTable(result.output);
+        deliverSamplerIdentity(sampler);
+    })
+        .finally(() => {
+        sampler.identityInFlight = undefined;
+    });
+    return sampler.identityInFlight;
+}
+function runMarkerScan(sampler) {
+    sampler.markerScannedAt = Date.now();
+    sampler.markerInFlight = readPosixMarkerOutput(sampler.execFile)
+        .then((result) => {
+        sampler.markerFailure = result.failure;
+        sampler.markerScan = result.output === null
+            ? undefined
+            : parsePosixMarkerScan(result.output);
+        deliverSamplerMarkers(sampler, 'observation');
+    })
+        .finally(() => {
+        sampler.markerInFlight = undefined;
+    });
+    return sampler.markerInFlight;
+}
+function scanSamplerMarkers(sampler, force) {
+    if (sampler.markerInFlight)
+        return sampler.markerInFlight;
+    const now = Date.now();
+    if (!force &&
+        Number.isFinite(sampler.markerScannedAt) &&
+        now - sampler.markerScannedAt < PROCESS_TREE_MARKER_INTERVAL_MS)
+        return Promise.resolve();
+    return runMarkerScan(sampler);
+}
+function schedulePosixSampler(sampler) {
+    if (sampler.timer)
+        clearTimeout(sampler.timer);
+    sampler.timer = undefined;
+    if (sampler.states.size === 0)
+        return;
+    const now = Date.now();
+    const identityDelay = Math.max(0, PROCESS_TREE_IDENTITY_INTERVAL_MS - (now - sampler.identityScannedAt));
+    const markerDelay = [...sampler.states].some((state) => state.marker !== undefined)
+        ? Math.max(0, PROCESS_TREE_MARKER_INTERVAL_MS - (now - sampler.markerScannedAt))
+        : Number.POSITIVE_INFINITY;
+    const delayMs = Math.min(identityDelay, markerDelay);
+    sampler.timer = setTimeout(() => {
+        sampler.timer = undefined;
+        const current = Date.now();
+        const scans = [];
+        if (current - sampler.identityScannedAt >= PROCESS_TREE_IDENTITY_INTERVAL_MS) {
+            scans.push(scanSamplerIdentity(sampler, false));
+        }
+        if (markerDelay !== Number.POSITIVE_INFINITY &&
+            current - sampler.markerScannedAt >= PROCESS_TREE_MARKER_INTERVAL_MS) {
+            scans.push(scanSamplerMarkers(sampler, false));
+        }
+        void Promise.all(scans).finally(() => schedulePosixSampler(sampler));
+    }, delayMs);
+    sampler.timer.unref();
+}
+function stopObservingPosixState(state) {
+    const sampler = state.sampler;
+    if (!sampler)
+        return;
+    state.sampler = undefined;
+    sampler.states.delete(state);
+    schedulePosixSampler(sampler);
+}
+async function readImmediatePosixSnapshot(state, stage) {
+    const sampler = state.sampler ?? getPosixProcessSampler(state.dependencies.execFile ?? defaultExecFile);
+    if (state.marker === undefined)
+        await scanSamplerIdentity(sampler, true);
+    else
+        await scanSamplerMarkers(sampler, true);
+    if (state.marker === undefined && sampler.identityFailure) {
+        latchObservationFailure(state, cleanupUnconfirmed('POSIX process identity lookup failed.'));
+        return undefined;
+    }
+    if (state.marker !== undefined && sampler.markerFailure) {
+        latchObservationFailure(state, posixMarkerLookupFailure({
+            table: new Map(),
+            markerPids: new Set(),
+            markerLookupSucceeded: false,
+            markerLookupAttempts: 1,
+            markerLookupFailure: sampler.markerFailure,
+            confirmedUnmarkedPids: new Set(),
+        }, stage));
+        return undefined;
+    }
+    const snapshot = snapshotFromSampler(state, sampler);
+    if (!snapshot)
+        return undefined;
+    acceptPosixSnapshot(state, snapshot, stage);
+    return snapshot;
+}
 function createProcessTreeObservation(pid, marker, dependencies, startLookup, lease) {
     const observation = {
         pid,
@@ -410,8 +723,7 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup, le
             const state = observationStates.get(observation);
             if (state) {
                 state.disposed = true;
-                if (state.pollTimer)
-                    clearTimeout(state.pollTimer);
+                stopObservingPosixState(state);
             }
         },
     };
@@ -423,6 +735,7 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup, le
         lease,
         dependencies,
         rootDiscoveryPending: true,
+        initialWindowsLookupSucceeded: false,
         descendants: new Map(),
         failureListeners: new Set(),
         disposed: false,
@@ -432,34 +745,37 @@ function createProcessTreeObservation(pid, marker, dependencies, startLookup, le
     if (!startLookup)
         return observation;
     const execFileImpl = dependencies.execFile ?? defaultExecFile;
-    const refresh = () => state.platform === 'win32'
-        ? readWindowsProcessTable(execFileImpl).then((table) => {
-            if (!state.disposed && table)
+    if (state.platform === 'win32') {
+        state.initialLookup = readWindowsProcessTable(execFileImpl).then((table) => {
+            if (!state.disposed && table) {
+                state.initialWindowsLookupSucceeded = true;
                 refreshObservedProcesses(state, table);
-        })
-        : 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 = () => {
+        return observation;
+    }
+    const sampler = getPosixProcessSampler(execFileImpl);
+    const periodic = dependencies.enforceCooperativeProcessGroup === true;
+    if (periodic) {
+        state.sampler = sampler;
+        sampler.states.add(state);
+    }
+    state.initialLookup = (marker === undefined
+        ? scanSamplerIdentity(sampler, true)
+        : Promise.all([
+            ...(periodic ? [scanSamplerIdentity(sampler, true)] : []),
+            scanSamplerMarkers(sampler, true),
+        ])).then(() => {
         if (state.disposed)
             return;
-        state.pollTimer = setTimeout(() => {
-            state.pollTimer = undefined;
-            void refresh().finally(scheduleRefresh);
-        }, PROCESS_TREE_OBSERVATION_INTERVAL_MS);
-        state.pollTimer.unref();
-    };
-    state.initialLookup = refresh();
-    if (state.platform !== 'win32')
-        void state.initialLookup.finally(scheduleRefresh);
+        if (periodic)
+            return;
+        const snapshot = snapshotFromSampler(state, sampler);
+        if (snapshot)
+            acceptPosixSnapshot(state, snapshot, 'observation');
+    });
+    if (periodic)
+        void state.initialLookup.finally(() => schedulePosixSampler(sampler));
     return observation;
 }
 export function observeProcessTree(pid, marker, dependencies = {}, lease) {
@@ -489,8 +805,7 @@ function signalIdentity(identity, snapshot, signal, kill) {
     }
 }
 function safelyOwnedProcessGroup(state, snapshot) {
-    if (state.dependencies.enforceCooperativeProcessGroup !== true ||
-        state.marker === undefined ||
+    if (state.marker === undefined ||
         state.rootPgid === undefined ||
         state.rootPgid !== state.pid)
         return undefined;
@@ -498,6 +813,13 @@ function safelyOwnedProcessGroup(state, snapshot) {
     const members = [...snapshot.table].filter(([, entry]) => entry.pgid === pgid && !entry.state?.startsWith('Z'));
     if (members.length === 0)
         return undefined;
+    if (state.rootPgidMode === 'owned') {
+        const currentLeader = snapshot.table.get(pgid);
+        if (currentLeader !== undefined &&
+            currentLeader.startTime !== state.root?.startTime)
+            return undefined;
+        return pgid;
+    }
     const known = [state.root, ...state.descendants.values()];
     if (members.some(([pid, entry]) => !known.some((identity) => identity?.pid === pid && identity.startTime === entry.startTime)))
         return undefined;
@@ -527,7 +849,7 @@ function latchLiveDescendantCompletionFailure(state, snapshot) {
 async function runTaskkill(pid, execFileImpl) {
     return (await runCommand('taskkill', ['/PID', String(pid), '/T', '/F'], execFileImpl, PROCESS_TREE_COMMAND_TIMEOUT_MS)) !== null;
 }
-async function terminateWindowsProcessTree(state, requireConfirmedCleanup) {
+async function terminateWindowsProcessTree(state, requireConfirmedCleanup, allowUnobservedProcessOnNormalCompletion) {
     const execFileImpl = state.dependencies.execFile ?? defaultExecFile;
     if (!requireConfirmedCleanup) {
         if (!(await runTaskkill(state.pid, execFileImpl))) {
@@ -535,139 +857,142 @@ async function terminateWindowsProcessTree(state, requireConfirmedCleanup) {
         }
         return;
     }
+    const identitiesBeforeNormalCompletion = allowUnobservedProcessOnNormalCompletion
+        ? {
+            root: state.root,
+            descendants: new Map(state.descendants),
+        }
+        : undefined;
     await state.initialLookup;
     const table = await readWindowsProcessTable(execFileImpl);
     if (!table) {
         throw cleanupUnconfirmed('Windows process identity lookup failed.');
     }
     refreshObservedProcesses(state, table);
-    const rootTarget = identityMatches(state.root, table) ? state.root : undefined;
-    const liveDescendants = [...state.descendants.values()].filter((identity) => identityMatches(identity, table));
+    const root = identitiesBeforeNormalCompletion
+        ? identitiesBeforeNormalCompletion.root
+        : state.root;
+    const descendants = identitiesBeforeNormalCompletion?.descendants ?? state.descendants;
+    const observedIdentities = [root, ...descendants.values()].filter((identity) => identity !== undefined);
+    const candidatePids = collectDescendantProcessIds(state.pid, table);
+    const comparableCandidatePids = collectComparableWindowsDescendantProcessIds(root, table);
+    const hasInvalidCandidateEdge = [...candidatePids].some((pid) => !comparableCandidatePids.has(pid));
+    const hasUnobservedCandidate = [...candidatePids].some((pid) => !identityMatches(descendants.get(pid), table));
+    const observedPidWasReused = (candidateTable) => observedIdentities.some((identity) => {
+        const entry = candidateTable.get(identity.pid);
+        return entry !== undefined && entry.startTime !== identity.startTime;
+    });
+    const rootTarget = identityMatches(root, table) ? root : undefined;
+    const liveDescendants = [...descendants.values()].filter((identity) => identityMatches(identity, table));
     const liveDescendantPids = new Set(liveDescendants.map((identity) => identity.pid));
     const targets = rootTarget
         ? [rootTarget]
         : liveDescendants.filter((identity) => !liveDescendantPids.has(table.get(identity.pid).ppid));
-    const taskkillResults = await Promise.all(targets.map((identity) => runTaskkill(identity.pid, execFileImpl)));
+    const taskkillResults = hasInvalidCandidateEdge || hasUnobservedCandidate
+        ? []
+        : await Promise.all(targets.map((identity) => runTaskkill(identity.pid, execFileImpl)));
     if (taskkillResults.some((result) => !result)) {
         throw cleanupUnconfirmed('taskkill did not confirm termination.');
     }
     const verifiedTable = await readWindowsProcessTable(execFileImpl);
     if (!verifiedTable)
         throw cleanupUnconfirmed('Windows termination verification failed.');
+    const verifiedCandidatePids = collectDescendantProcessIds(state.pid, verifiedTable);
     const verifiedIdentities = [rootTarget, ...liveDescendants].filter((identity) => identity !== undefined);
     if (verifiedIdentities.some((identity) => identityMatches(identity, verifiedTable))) {
         throw cleanupUnconfirmed('a verified Windows process is still running.');
     }
-    if (requireConfirmedCleanup && targets.length === 0) {
-        throw cleanupUnconfirmed('no inherited-pipe process identity was observed.');
+    if (hasInvalidCandidateEdge) {
+        throw cleanupUnconfirmed(hasUnobservedCandidate
+            ? 'an unobserved Windows descendant candidate has invalid process creation order.'
+            : 'a Windows descendant candidate has invalid process creation order.');
+    }
+    if (hasUnobservedCandidate) {
+        throw cleanupUnconfirmed('an unobserved Windows descendant candidate was found after the root exited.');
+    }
+    if (verifiedCandidatePids.size > 0) {
+        throw cleanupUnconfirmed('a Windows descendant candidate is still running.');
+    }
+    const unobservedNormalCompletionIsAllowed = allowUnobservedProcessOnNormalCompletion &&
+        state.initialWindowsLookupSucceeded &&
+        !table.has(state.pid) &&
+        candidatePids.size === 0 &&
+        !verifiedTable.has(state.pid) &&
+        verifiedCandidatePids.size === 0;
+    if (requireConfirmedCleanup &&
+        targets.length === 0 &&
+        (observedPidWasReused(table) ||
+            observedPidWasReused(verifiedTable) ||
+            (observedIdentities.length === 0 && !unobservedNormalCompletionIsAllowed))) {
+        throw cleanupUnconfirmed(observedIdentities.length > 0
+            ? 'an observed Windows process identifier was reused.'
+            : 'no inherited-pipe process identity was observed.');
     }
 }
 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;
+    stopObservingPosixState(state);
     const kill = state.dependencies.kill ?? process.kill.bind(process);
-    const deadline = Date.now() + PROCESS_TREE_COMMAND_TIMEOUT_MS;
-    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;
+    let snapshot = await readImmediatePosixSnapshot(state, 'termination-start');
     if (!snapshot) {
         if (!requireConfirmedCleanup && allowInspectionUnavailable)
             return;
         throw state.failure ?? cleanupUnconfirmed('POSIX process identity 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);
     }
-    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 inspect(Math.max(1, deadline - Date.now()), 'termination-freeze');
-        if (!next) {
-            processGroupCurrentlyVerified = false;
-            break;
-        }
-        snapshot = next;
-        processGroupCurrentlyVerified = true;
-        const previousSize = state.descendants.size;
-        signalProcessGroup(safelyOwnedProcessGroup(state, snapshot), 'SIGSTOP', kill);
-        if (posixIdentityMatches(state.root, snapshot)) {
-            signalIdentity(state.root, snapshot, 'SIGSTOP', kill);
+    const liveIdentities = (current) => [state.root, ...state.descendants.values()].filter((identity) => posixIdentityMatches(identity, current) &&
+        !current.table.get(identity.pid)?.state?.startsWith('Z'));
+    const liveMarkerPids = (current) => state.marker === undefined
+        ? []
+        : [...current.markerPids].filter((pid) => pid !== state.lease?.sentinel.pid &&
+            !current.table.get(pid)?.state?.startsWith('Z'));
+    const signalOwned = (current, signal) => {
+        if (state.marker !== undefined && !current.markerLookupSucceeded)
+            return;
+        signalProcessGroup(safelyOwnedProcessGroup(state, current), signal, kill);
+        for (const identity of liveIdentities(current).reverse()) {
+            signalIdentity(identity, current, signal, kill);
         }
-        for (const identity of [...state.descendants.values()].reverse()) {
-            signalIdentity(identity, snapshot, 'SIGSTOP', kill);
+    };
+    const initialTargets = liveIdentities(snapshot);
+    const initialMarkerPids = liveMarkerPids(snapshot);
+    const initialProcessGroup = safelyOwnedProcessGroup(state, snapshot);
+    if (initialTargets.length === 0 &&
+        initialMarkerPids.length === 0 &&
+        initialProcessGroup === undefined) {
+        if (requireConfirmedCleanup && state.marker === undefined) {
+            throw cleanupUnconfirmed('no inherited-pipe process identity was observed.');
         }
-        const allFrozen = [state.root, ...state.descendants.values()].every((identity) => {
-            if (!posixIdentityMatches(identity, snapshot))
-                return true;
-            const processState = snapshot.table.get(identity.pid)?.state;
-            return processState?.startsWith('T') || processState?.startsWith('Z');
-        });
-        if (allFrozen && state.descendants.size === previousSize)
-            break;
-    }
-    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);
-    }
-    signalProcessGroup(ownedPgid, 'SIGKILL', kill);
-    if (!requireConfirmedCleanup) {
         if (state.failure)
             throw state.failure;
         return;
     }
-    const verified = await inspect(PROCESS_TREE_COMMAND_TIMEOUT_MS, 'termination-verification');
+    signalOwned(snapshot, 'SIGTERM');
+    await new Promise((resolve) => {
+        setTimeout(resolve, PROCESS_TREE_TERMINATION_GRACE_MS);
+    });
+    const killSnapshot = await readImmediatePosixSnapshot(state, 'termination-kill');
+    if (!killSnapshot) {
+        throw state.failure ?? cleanupUnconfirmed('POSIX termination audit failed.');
+    }
+    snapshot = killSnapshot;
+    signalOwned(snapshot, 'SIGKILL');
+    await new Promise((resolve) => {
+        setTimeout(resolve, PROCESS_TREE_TERMINATION_SETTLE_MS);
+    });
+    const verified = await readImmediatePosixSnapshot(state, '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) {
+    if (liveIdentities(verified).length > 0) {
         throw state.failure ?? cleanupUnconfirmed('a verified POSIX descendant is still running.');
     }
-    const unobservedMarkedProcess = state.marker === undefined
-        ? false
-        : [...verified.markerPids].some((pid) => pid !== state.lease?.sentinel.pid &&
-            !verified.table.get(pid)?.state?.startsWith('Z'));
-    if (unobservedMarkedProcess) {
+    if (liveMarkerPids(verified).length > 0) {
         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;
 }
@@ -681,7 +1006,7 @@ export async function terminateProcessTree(pid, killDirectChild, dependencies =
             throw cleanupUnconfirmed('process observation is invalid.');
         }
         if (platform === 'win32') {
-            await terminateWindowsProcessTree(state, options.requireConfirmedCleanup ?? false);
+            await terminateWindowsProcessTree(state, options.requireConfirmedCleanup ?? false, options.allowUnobservedWindowsProcessOnNormalCompletion ?? false);
             return;
         }
         await terminatePosixProcessTree(state, options.requireConfirmedCleanup ?? false, options.allowInspectionUnavailable ?? false, options.requireDescendantsExitedBeforeCompletion ?? false);