@deepseek-ai/dsh-subprocess-local 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/index.js

@@ -1,1011 +1,608 @@
-import { closeSync, constants, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { C as bindManagedProcess, D as validateSubprocessSpec, E as spawnSubprocess, O as createProcessInspector, S as loadLinuxExecve, T as prepareManagedProcessBinding, _ as parseWindowsRunnerResult, c as runnerStdio, d as cleanupLinuxLaunchFiles, l as spawnRunnerInvocation, m as deserializeRunnerError, n as WINDOWS_RUNNER_SELECTION, o as runnerEnvironment, p as createLinuxLaunchFiles, s as runnerInvocationAvailable, u as targetEnvironment, w as childEnv, y as readLinuxStartupError } from "./runner-launch-COYGu0Dl.js";
+import { closeSync, constants, existsSync, openSync } from "node:fs";
 import { access, stat } from "node:fs/promises";
-import { delimiter, extname, isAbsolute, join, resolve } from "node:path";
+import { delimiter, extname, isAbsolute, resolve } from "node:path";
 import * as nodePty from "node-pty";
-import { SubprocessRuntime, scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
-import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { SubprocessRuntime } from "@deepseek-ai/dsh-subprocess";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { constants as constants$1, tmpdir } from "node:os";
+import { constants as constants$1, devNull } from "node:os";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
-import koffi from "koffi";
-import { Buffer as Buffer$1 } from "node:buffer";
+import { loadWin32ProcessBindings, probeCurrentTokenJobSupport } from "@deepseek-ai/dsh-win32-process";
+import { Buffer } from "node:buffer";
 import { PassThrough } from "node:stream";
-//#region lib/types/windows-inspector.js
-/**
-* Windows process-table operations for terminal readiness, signalling, and
-* teardown: Toolhelp32 snapshot enumeration with GetProcessTimes creation-time
-* identity and process-handle wait-state liveness, the shell pid as a pseudo
-* process group (Windows has no POSIX groups), and taskkill tree signalling.
-* The koffi bindings load lazily so
-* non-Windows processes never touch Win32 libraries; all decision logic takes
-* an injectable internals boundary so suites can pin it on any host.
-* @module dsh-subprocess-local/windows-inspector
-*/
-/**
-* Walk a process table from one root in children-first order, retaining only
-* members whose start identity is readable (unreadable members are detector
-* misses, exactly like an unreadable `/proc` entry on Linux).
-* @param entries - the process table snapshot.
-* @param rootPid - the tree root to descend from.
-* @param started - creation-time identity resolver for one member.
-* @returns the root and its current transitive descendants, children first.
-*/
-function windowsProcessTree(entries, rootPid, started) {
-	const root = new Map(entries.map((entry) => [entry.pid, entry])).get(rootPid);
-	if (root === void 0) return [];
-	const byParent = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const children = byParent.get(entry.parentPid) ?? [];
-		children.push(entry);
-		byParent.set(entry.parentPid, children);
-	}
-	const visited = /* @__PURE__ */ new Set();
-	const result = [];
-	const visit = (entry) => {
-		if (visited.has(entry.pid)) return;
-		visited.add(entry.pid);
-		for (const child of byParent.get(entry.pid) ?? []) visit(child);
-		const identity = started(entry.pid);
-		if (identity !== void 0) result.push({
-			pid: entry.pid,
-			started: identity
+//#region lib/types/linux-scope.js
+/** Linux user-systemd scope launch and managed-range ownership. */
+const SYSTEMCTL_TIMEOUT_MS = 5e3;
+const SCOPE_INITIAL_POLL_INTERVAL_MS = 50;
+const MISSING_UNIT = /\bunit\b[^\r\n]*(?:could not be found|not found|not loaded)/iu;
+function managerEnvironment() {
+	const environment = childEnv({ LC_ALL: "C" });
+	delete environment.SYSTEMD_LOG_TARGET;
+	return environment;
+}
+function quietSystemdEnvironment() {
+	return childEnv({
+		LC_ALL: "C",
+		SYSTEMD_LOG_TARGET: "null"
+	});
+}
+function querySystemctl(command, args) {
+	return new Promise((resolveResult) => {
+		execFile(command, [...args], {
+			encoding: "utf8",
+			env: managerEnvironment(),
+			timeout: SYSTEMCTL_TIMEOUT_MS
+		}, (error, stdout, stderr) => {
+			const code = error === null ? 0 : error.code;
+			resolveResult({
+				status: typeof code === "number" ? code : null,
+				stdout,
+				stderr,
+				...error === null ? {} : { error }
+			});
 		});
-	};
-	visit(root);
-	return result;
+	});
 }
-/**
-* Windows {@link ProcessInspector}. The shell pid stands in for a foreground
-* process group: it is a stable pseudo-group that lets the prompt-marker
-* readiness path compare foreground identities, while every actual signal
-* targets the console-wide tree through taskkill (SIGINT is delivered by the
-* terminal handle as a `\x03` input write and never reaches this layer).
-*/
-var WindowsProcessInspector = class {
-	internals;
-	constructor(internals = defaultWindowsProcessInternals()) {
-		this.internals = internals;
-	}
-	foregroundPgid(shellPid) {
-		return shellPid;
-	}
-	isStdinWaiting(_pgid, _shellPid) {
-		return false;
-	}
-	isAlive(identity) {
-		const state = this.internals.processState(identity.pid);
-		return state?.active === true && state.started === identity.started;
-	}
-	snapshot() {
-		let entries;
-		return {
-			tree: (rootPid) => windowsProcessTree(entries ??= this.internals.snapshot(), rootPid, (pid) => this.internals.processState(pid)?.started),
-			session: () => [],
-			alive: (identity) => this.isAlive(identity)
-		};
-	}
-	signalGroup(pgid, signal) {
-		this.internals.taskkill(pgid, signal === "SIGKILL");
-	}
-	signalProcess(identity, signal) {
-		if (this.isAlive(identity)) this.internals.taskkill(identity.pid, signal === "SIGKILL");
-	}
-};
-/**
-* Create the Windows process inspector.
-* @param internals - injectable process operations; defaults to the koffi-backed table.
-* @returns the Windows inspector.
-*/
-function createWindowsProcessInspector(internals = defaultWindowsProcessInternals()) {
-	return new WindowsProcessInspector(internals);
+function unitStem(prefix) {
+	return `${prefix}-${String(process.pid)}-${randomBytes(6).toString("hex")}`;
 }
-/** Terminate one Windows process tree with taskkill, contained like POSIX group signalling. */
-function taskkillTree(pid, force) {
-	if (pid <= 0) return;
-	spawnSync("taskkill", [
-		"/PID",
-		String(pid),
-		"/T",
-		...force ? ["/F"] : []
-	], { stdio: "ignore" });
+function sleepWithAbort(delayMs, signal) {
+	return setTimeout$1(delayMs, void 0, { signal });
 }
 /**
-* True for NULL and INVALID_HANDLE_VALUE returns from Win32 handle APIs.
-* @param value - a handle as koffi may hand it back (pointer, null, or 0n).
-* @returns whether the value signals an invalid handle.
+* Confirm this exact runner entry and libc execve binding without a probe mode.
+* @param internals - optional runner and libc-binding seams used by tests.
+* @returns whether the bootstrap can enter the final target.
 */
-function isInvalidHandle(value) {
-	if (value === null || value === void 0) return true;
-	const asBigInt = value;
-	return asBigInt === 0n || asBigInt === 18446744073709551615n || asBigInt === -1n;
+function probeLinuxBootstrap(internals = {}) {
+	try {
+		(internals.loadLinuxExecve ?? loadLinuxExecve)();
+		const invocation = internals.runnerInvocation ?? (internals.resolveRunnerInvocation ?? spawnRunnerInvocation)();
+		return (internals.runnerAvailable ?? runnerInvocationAvailable)(invocation);
+	} catch {
+		return false;
+	}
 }
-const PVOID = koffi.pointer("void");
 /**
-* Resolve the koffi Win32 struct types once. Registration is lazy and cached
-* because koffi's type registry is global per process: test runners that
-* re-evaluate this module (a hoisted `vi.mock` re-imports the graph) must not
-* re-register the names.
+* Confirm current literal-argv transient-scope support before selecting native launch.
+* @param internals - optional systemd command seams used by tests.
+* @returns whether the current user manager supports the required scope invocation.
 */
-function win32Structs() {
-	if (cachedStructs !== void 0) return cachedStructs;
-	const PROCESSENTRY32W = koffi.struct("PROCESSENTRY32W", {
-		dwSize: "uint32",
-		cntUsage: "uint32",
-		th32ProcessID: "uint32",
-		th32DefaultHeapID: PVOID,
-		th32ModuleID: "uint32",
-		cCntThreads: "uint32",
-		th32ParentProcessID: "uint32",
-		pcPriClassBase: "int32",
-		dwFlags: "uint32",
-		szExeFile: koffi.array("char16", 260)
-	});
-	const FILETIME = koffi.struct("FILETIME", {
-		dwLowDateTime: "uint32",
-		dwHighDateTime: "uint32"
+function probeLinuxScope(internals = {}) {
+	const unitBase = unitStem("dsh-subprocess-probe");
+	const result = (internals.spawnSync ?? spawnSync)(internals.systemdRun ?? "systemd-run", [
+		"--user",
+		"--scope",
+		"--quiet",
+		"--collect",
+		"--expand-environment=no",
+		`--unit=${unitBase}`,
+		"--",
+		internals.systemctl ?? "systemctl",
+		"--user",
+		"show",
+		`${unitBase}.scope`,
+		"--property=ActiveState",
+		"--value"
+	], {
+		env: quietSystemdEnvironment(),
+		stdio: "ignore",
+		timeout: SYSTEMCTL_TIMEOUT_MS
 	});
-	/* v8 ignore start -- a layout-mismatch guard fires only on ABI breakage; the windows-native suites exercise the real struct. */
-	if (PROCESSENTRY32W.size !== 568) throw new Error(`PROCESSENTRY32W layout mismatch: koffi computed ${PROCESSENTRY32W.size}, Windows headers say 568`);
-	/* v8 ignore stop */
-	cachedStructs = {
-		PROCESSENTRY32W,
-		FILETIME
-	};
-	return cachedStructs;
+	return result.error === void 0 && result.status === 0;
 }
-let cachedStructs;
-const TH32CS_SNAPPROCESS = 2;
-const WAIT_OBJECT_0 = 0;
-const WAIT_TIMEOUT = 258;
-let cachedBindings;
 /**
-* Resolve the lazy Win32 bindings (throws the first binding failure, fail-closed).
-* @returns the cached binding table.
+* Confirm that the current user manager remains reachable after a positive deep probe.
+* @param internals - optional systemctl seam used by tests.
+* @returns whether one lightweight manager query succeeds.
 */
-function win32Bindings() {
-	if (cachedBindings !== void 0) return cachedBindings;
-	const { PROCESSENTRY32W, FILETIME } = win32Structs();
-	const kernel32 = koffi.load("kernel32.dll");
-	const bind = (name, result, args) => kernel32.func("__stdcall", name, result, args);
-	cachedBindings = {
-		createToolhelp32Snapshot: bind("CreateToolhelp32Snapshot", PVOID, ["uint32", "uint32"]),
-		process32FirstW: bind("Process32FirstW", "int", [PVOID, koffi.pointer(PROCESSENTRY32W)]),
-		process32NextW: bind("Process32NextW", "int", [PVOID, koffi.pointer(PROCESSENTRY32W)]),
-		openProcess: bind("OpenProcess", PVOID, [
-			"uint32",
-			"int",
-			"uint32"
-		]),
-		getProcessTimes: bind("GetProcessTimes", "int", [
-			PVOID,
-			koffi.pointer(FILETIME),
-			koffi.pointer(FILETIME),
-			koffi.pointer(FILETIME),
-			koffi.pointer(FILETIME)
-		]),
-		waitForSingleObject: bind("WaitForSingleObject", "uint32", [PVOID, "uint32"]),
-		closeHandle: bind("CloseHandle", "int", [PVOID])
-	};
-	return cachedBindings;
+function probeLinuxManager(internals = {}) {
+	const result = (internals.spawnSync ?? spawnSync)(internals.systemctl ?? "systemctl", [
+		"--user",
+		"show",
+		"--property=Version",
+		"--value"
+	], {
+		env: managerEnvironment(),
+		stdio: "ignore",
+		timeout: SYSTEMCTL_TIMEOUT_MS
+	});
+	return result.error === void 0 && result.status === 0;
 }
 /**
-* Allocate koffi memory as a branded {@link NativePtr}; koffi's TS types are
-* `any`, so the cast goes through `unknown` to keep the unsafe surface here.
-* @param type - the koffi type to allocate.
-* @param count - element count.
-* @returns the branded allocation pointer.
+* Re-check every Linux native prerequisite for one eligible spawn.
+* @param internals - optional native capability seams used by tests.
+* @returns whether the Linux native containment path is currently available.
 */
-function allocNative(type, count) {
-	return koffi.alloc(type, count);
+function probeLinuxNative(internals = {}) {
+	return probeLinuxBootstrap(internals) && probeLinuxScope(internals);
 }
-/** Enumerate the current process table through Toolhelp32. */
-function snapshotWindowsProcesses(bindings) {
-	const { PROCESSENTRY32W } = win32Structs();
-	const snapshot = bindings.createToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-	/* v8 ignore next -- an invalid snapshot for the process flag is not producible through the public API;
-	the guard mirrors POSIX's unreadable-proc tolerance and isInvalidHandle is unit-tested. */
-	if (isInvalidHandle(snapshot)) return [];
-	const entries = [];
-	try {
-		const entry = allocNative(PROCESSENTRY32W, 1);
-		koffi.encode(entry, "uint32", PROCESSENTRY32W.size);
-		let ok = bindings.process32FirstW(snapshot, entry);
-		while (ok !== 0) {
-			const record = koffi.decode(entry, PROCESSENTRY32W);
-			entries.push({
-				pid: record.th32ProcessID,
-				parentPid: record.th32ParentProcessID
-			});
-			ok = bindings.process32NextW(snapshot, entry);
+var SystemdScopeOwner = class {
+	unit;
+	files;
+	direct;
+	systemctl;
+	runSync;
+	query;
+	sleep;
+	establishment = "pending";
+	stopped = false;
+	observation;
+	killFailure;
+	wakeGeneration = 0;
+	wakeWaiter;
+	constructor(unit, files, direct, systemctl, runSync, query, sleep) {
+		this.unit = unit;
+		this.files = files;
+		this.direct = direct;
+		this.systemctl = systemctl;
+		this.runSync = runSync;
+		this.query = query;
+		this.sleep = sleep;
+	}
+	signal(signal) {
+		if (this.stopped) return;
+		this.observeRequestConsumption();
+		const directFallbackRequired = this.establishment === "pending";
+		if (directFallbackRequired && this.direct.running()) this.direct.signal(signal);
+		const result = this.runSync(this.systemctl, [
+			"--user",
+			"kill",
+			"--kill-whom=all",
+			`--signal=${signal}`,
+			this.unit
+		], {
+			encoding: "utf8",
+			env: managerEnvironment(),
+			timeout: SYSTEMCTL_TIMEOUT_MS
+		});
+		this.wakeObservation();
+		if (result.error === void 0 && result.status === 0) {
+			if (signal === "SIGKILL") this.killFailure = void 0;
+			return;
+		}
+		if (!directFallbackRequired && this.direct.running()) this.direct.signal(signal);
+		if (signal === "SIGKILL") {
+			const output = `${result.stdout}\n${result.stderr}`;
+			if (!MISSING_UNIT.test(output)) this.killFailure = result.error ?? /* @__PURE__ */ new Error(`systemctl could not signal ${this.unit}: ${output.trim() || `exit ${String(result.status)}`}`);
 		}
-	} finally {
-		bindings.closeHandle(snapshot);
-	}
-	return entries;
-}
-/** Read one process's creation identity and current wait state. */
-function windowsProcessState(bindings, pid) {
-	const { FILETIME } = win32Structs();
-	const handle = bindings.openProcess(1052672, 0, pid);
-	if (isInvalidHandle(handle)) return void 0;
-	try {
-		const creation = allocNative(FILETIME, 1);
-		const exit = allocNative(FILETIME, 1);
-		const kernel = allocNative(FILETIME, 1);
-		const user = allocNative(FILETIME, 1);
-		/* v8 ignore next -- a GetProcessTimes failure after a successful open races process exit and
-		cannot be staged deterministically; the absent-process path is covered and the caller
-		treats undefined as a detector miss. */
-		if (bindings.getProcessTimes(handle, creation, exit, kernel, user) === 0) return void 0;
-		const record = koffi.decode(creation, FILETIME);
-		const wait = bindings.waitForSingleObject(handle, 0);
-		/* v8 ignore next -- an opened process handle has exactly one of these two
-		zero-time wait states; an unexpected Win32 failure is an unreadable process. */
-		if (wait !== WAIT_OBJECT_0 && wait !== WAIT_TIMEOUT) return void 0;
-		return {
-			started: `${record.dwHighDateTime}:${record.dwLowDateTime}`,
-			active: wait === WAIT_TIMEOUT
-		};
-	} finally {
-		bindings.closeHandle(handle);
-	}
-}
-/** The koffi-backed default internals; bindings resolve lazily on first use. */
-function defaultWindowsProcessInternals() {
-	return {
-		snapshot: () => snapshotWindowsProcesses(win32Bindings()),
-		processState: (pid) => windowsProcessState(win32Bindings(), pid),
-		taskkill: taskkillTree
-	};
-}
-//#endregion
-//#region lib/types/process-inspector.js
-/** Platform process-table inspection for terminal readiness, signals, and teardown. */
-/* v8 ignore start -- thin OS bindings; injected logic is unit-tested and real platform composition exercises them. */
-const DEFAULT_INTERNALS = {
-	readFile: (path) => readFileSync(path, "utf8"),
-	readDir: (path) => readdirSync(path),
-	readLink: (path) => readlinkSync(path, "utf8"),
-	stat: (path) => statSync(path),
-	open: (path) => openSync(path, "r"),
-	read: (fd, buffer, length, position) => readSync(fd, buffer, 0, length, position),
-	close: closeSync,
-	exec: (file, args) => execFileSync(file, args, { encoding: "utf8" }),
-	kill: (pid, signal) => process.kill(pid, signal)
-};
-/**
-* Parse fields used from Linux `/proc/<pid>/stat`, including parenthesized comm text.
-* @param text - complete stat line.
-* @returns Parsed identity/group fields, or undefined for malformed input.
-*/
-function parseProcStat(text) {
-	const open = text.indexOf("(");
-	const close = text.lastIndexOf(")");
-	if (open <= 0 || close <= open) return void 0;
-	const pid = Number(text.slice(0, open).trim());
-	const rest = text.slice(close + 2).trim().split(/\s+/);
-	const state = rest[0] || "";
-	const parentPid = Number(rest[1]);
-	const pgrp = Number(rest[2]);
-	const session = Number(rest[3]);
-	const ttyDevice = Number(rest[4]);
-	const tpgid = Number(rest[5]);
-	const started = rest[19];
-	if (![
-		pid,
-		parentPid,
-		pgrp,
-		session,
-		ttyDevice,
-		tpgid
-	].every(Number.isSafeInteger) || state.length !== 1 || started === void 0) return void 0;
-	return {
-		pid,
-		parentPid,
-		pgrp,
-		session,
-		state,
-		ttyDevice,
-		tpgid,
-		started
-	};
-}
-function readLinuxStat(internals, pid) {
-	try {
-		return parseProcStat(internals.readFile(`/proc/${pid}/stat`));
-	} catch (_unreadableProcEntry) {
-		return;
-	}
-}
-function linuxDeviceNumber(value) {
-	return value >>> 0;
-}
-function readLinuxTerminalDevice(internals, pid, ttyDevice, tid) {
-	const terminalDevice = linuxDeviceNumber(ttyDevice);
-	if (terminalDevice === 0) return void 0;
-	const path = tid === void 0 ? `/proc/${pid}/fd/0` : `/proc/${pid}/task/${tid}/fd/0`;
-	try {
-		if (internals.readLink(path) === "/dev/tty") return terminalDevice;
-		const status = internals.stat(path);
-		return status.isCharacterDevice() && linuxDeviceNumber(status.rdev) === terminalDevice ? terminalDevice : void 0;
-	} catch (_unreadableStdinDevice) {
-		return;
-	}
-}
-/**
-* Report whether a Linux process group has an executing member. `false`
-* means the group contains only zombie/dead entries; `undefined` means the
-* process table could not prove either outcome.
-* @param processGroupId - POSIX process-group id to inspect.
-* @param internals - injectable process-table operations.
-* @returns Live-member presence, or `undefined` when unavailable/absent.
-*/
-function linuxProcessGroupHasLiveMembers(processGroupId, internals = DEFAULT_INTERNALS) {
-	let entries;
-	try {
-		entries = internals.readDir("/proc");
-	} catch (_unreadableProcDirectory) {
-		return;
-	}
-	let matched = false;
-	for (const entry of entries) {
-		if (!/^\d+$/.test(entry)) continue;
-		const stat = readLinuxStat(internals, Number(entry));
-		if (stat?.pgrp !== processGroupId) continue;
-		matched = true;
-		if (!/^[ZXx]$/.test(stat.state)) return true;
 	}
-	return matched ? false : void 0;
-}
-function numericEntries(internals, path) {
-	try {
-		return internals.readDir(path).filter((entry) => /^\d+$/.test(entry)).map(Number);
-	} catch (_unreadableProcDirectory) {
-		return [];
+	terminateForHostExit() {
+		if (this.stopped) return;
+		try {
+			if (this.direct.running()) this.direct.signal("SIGKILL");
+		} catch {}
+		try {
+			this.runSync(this.systemctl, [
+				"--user",
+				"kill",
+				"--kill-whom=all",
+				"--signal=SIGKILL",
+				this.unit
+			], {
+				env: managerEnvironment(),
+				stdio: "ignore",
+				timeout: SYSTEMCTL_TIMEOUT_MS
+			});
+		} catch {}
 	}
-}
-function readSyscall(internals, pid, tid) {
-	try {
-		const text = internals.readFile(`/proc/${pid}/task/${tid}/syscall`).trim();
-		if (text === "running" || text.startsWith("-1 ")) return void 0;
-		const fields = text.split(/\s+/);
-		const number = Number(fields[0]);
-		const args = fields.slice(1, 7).map((field) => Number.parseInt(field, 16));
-		if (!Number.isSafeInteger(number) || args.some((value) => !Number.isSafeInteger(value))) return void 0;
+	observeRequestConsumption() {
+		if (this.establishment === "pending" && !existsSync(this.files.requestPath)) this.establishment = "established";
+	}
+	absentUnit() {
+		this.observeRequestConsumption();
+		if (this.establishment === "established") return false;
+		if (!this.direct.running() && existsSync(this.files.requestPath)) return false;
+		if (this.killFailure !== void 0) throw this.killFailure;
+		return true;
+	}
+	parseUnitState(stdout) {
+		const values = /* @__PURE__ */ new Map();
+		for (const line of stdout.split(/\r?\n/u)) {
+			if (line === "") continue;
+			const separator = line.indexOf("=");
+			if (separator <= 0) throw new Error(`systemctl returned malformed state for ${this.unit}: ${JSON.stringify(stdout.trim())}`);
+			const name = line.slice(0, separator);
+			if (values.has(name)) throw new Error(`systemctl returned duplicate ${name} for ${this.unit}`);
+			values.set(name, line.slice(separator + 1));
+		}
+		const loadState = values.get("LoadState");
+		const activeState = values.get("ActiveState");
+		if (values.size !== 2 || loadState === void 0 || activeState === void 0) throw new Error(`systemctl returned incomplete state for ${this.unit}: ${JSON.stringify(stdout.trim())}`);
 		return {
-			number,
-			args
+			loadState,
+			activeState
 		};
-	} catch (_unreadableSyscall) {
-		return;
 	}
-}
-function readMemory(internals, pid, address, length) {
-	let fd;
-	try {
-		fd = internals.open(`/proc/${pid}/mem`);
-		const buffer = Buffer.alloc(length);
-		const count = internals.read(fd, buffer, length, address);
-		return buffer.subarray(0, count);
-	} catch (_unreadableProcessMemory) {
-		return;
-	} finally {
-		if (fd !== void 0) internals.close(fd);
-	}
-}
-function fdSetHasStdin(internals, pid, address) {
-	return address !== 0 && (readMemory(internals, pid, address, 8)?.[0] ?? 0) % 2 === 1;
-}
-function pollHasStdin(internals, pid, address, count) {
-	if (address === 0 || count <= 0) return false;
-	const memory = readMemory(internals, pid, address, Math.min(count, 1024) * 8);
-	if (memory === void 0) return false;
-	for (let offset = 0; offset + 8 <= memory.length; offset += 8) if (memory.readInt32LE(offset) === 0 && (memory.readInt16LE(offset + 4) & 1) !== 0) return true;
-	return false;
-}
-function epollHasStdin(internals, pid, tid, epfd) {
-	try {
-		return internals.readFile(`/proc/${pid}/task/${tid}/fdinfo/${epfd}`).split("\n").some((line) => /^tfd:\s+0\b/.test(line.trim()));
-	} catch (_unreadableFdInfo) {
-		return false;
-	}
-}
-const SYSCALLS = {
-	x64: {
-		read: 0,
-		select: 23,
-		pselect: 270,
-		poll: 7,
-		ppoll: 271,
-		epollWait: 232,
-		epollPwait: 281
-	},
-	arm64: {
-		read: 63,
-		pselect: 72,
-		ppoll: 73,
-		epollPwait: 22
-	}
-};
-const SUPPORTED_SYSCALL_TABLES = Object.values(SYSCALLS);
-function linuxSyscallTables(arch) {
-	const primary = SYSCALLS[arch];
-	if (primary === void 0) return void 0;
-	return [primary, ...SUPPORTED_SYSCALL_TABLES.filter((table) => table !== primary)];
-}
-function syscallWaitsOnStdin(internals, pid, tid, syscall, tables) {
-	const [a0 = 0, a1 = 0, a2 = 0] = syscall.args;
-	for (const table of tables) {
-		if (syscall.number === table.read) return a0 === 0;
-		if (syscall.number === table.select || syscall.number === table.pselect) return a0 >= 1 && fdSetHasStdin(internals, pid, a1);
-		if (syscall.number === table.poll || syscall.number === table.ppoll) return a1 >= 1 && pollHasStdin(internals, pid, a0, a1);
-		if (syscall.number === table.epollWait || syscall.number === table.epollPwait) return a2 >= 1 && epollHasStdin(internals, pid, tid, a0);
-	}
-	return false;
-}
-var PosixProcessInspector = class {
-	internals;
-	constructor(internals) {
-		this.internals = internals;
+	async rangeActive() {
+		this.observeRequestConsumption();
+		const result = await this.query(this.systemctl, [
+			"--user",
+			"show",
+			this.unit,
+			"--property=LoadState",
+			"--property=ActiveState"
+		]);
+		const output = `${result.stdout}\n${result.stderr}`;
+		if (result.status === 0) {
+			const { loadState, activeState } = this.parseUnitState(result.stdout);
+			if (loadState === "not-found" && activeState === "inactive") return this.absentUnit();
+			if (loadState !== "loaded") throw new Error(`systemctl returned unknown state for ${this.unit}: ${JSON.stringify({
+				loadState,
+				activeState
+			})}`);
+			this.establishment = "established";
+			if (activeState === "inactive" || activeState === "failed") return false;
+			if (![
+				"active",
+				"activating",
+				"reloading",
+				"deactivating"
+			].includes(activeState)) throw new Error(`systemctl returned unknown ActiveState for ${this.unit}: ${JSON.stringify(activeState)}`);
+			if (this.killFailure !== void 0) throw this.killFailure;
+			return true;
+		}
+		if (!MISSING_UNIT.test(output)) {
+			if (result.error !== void 0) throw result.error;
+			throw new Error(`systemctl could not read ${this.unit}: ${output.trim() || `exit ${String(result.status)}`}`);
+		}
+		return this.absentUnit();
+	}
+	wakeObservation() {
+		this.wakeGeneration += 1;
+		this.wakeWaiter?.resolve();
+		this.wakeWaiter = void 0;
+	}
+	async waitForPoll(delayMs, generation) {
+		if (generation !== this.wakeGeneration) return;
+		const wake = Promise.withResolvers();
+		const waiter = {
+			generation,
+			resolve: wake.resolve
+		};
+		const sleepController = new AbortController();
+		this.wakeWaiter = waiter;
+		try {
+			await Promise.race([this.sleep(delayMs, sleepController.signal), wake.promise]);
+		} finally {
+			sleepController.abort();
+			if (this.wakeWaiter === waiter) this.wakeWaiter = void 0;
+		}
 	}
-	signalGroup(pgid, signal) {
-		this.internals.kill(-pgid, signal);
+	async waitForExit() {
+		if (this.stopped) return;
+		this.observation ??= (async () => {
+			let pollIntervalMs = SCOPE_INITIAL_POLL_INTERVAL_MS;
+			let generation = this.wakeGeneration;
+			while (await this.rangeActive()) {
+				await this.waitForPoll(pollIntervalMs, generation);
+				generation = this.wakeGeneration;
+				if (this.establishment === "established") pollIntervalMs = Math.min(pollIntervalMs * 2, SYSTEMCTL_TIMEOUT_MS);
+			}
+			this.stopped = true;
+		})().catch((error) => {
+			this.observation = void 0;
+			throw error;
+		});
+		await this.observation;
 	}
-	signalProcess(identity, signal) {
-		if (this.isAlive(identity)) this.internals.kill(identity.pid, signal);
+	cleanup() {
+		cleanupLinuxLaunchFiles(this.files);
 	}
 };
-function quiescent(state) {
-	return state !== void 0 && /^[ZXx]$/.test(state);
+function scopeArgs(unitBase, invocation, argv) {
+	return [
+		"--user",
+		"--scope",
+		"--quiet",
+		"--collect",
+		"--expand-environment=no",
+		`--unit=${unitBase}`,
+		"--",
+		...invocation,
+		"--",
+		...argv
+	];
 }
-var PosixProcessSnapshot = class {
-	rows;
-	byPid;
-	constructor(rows) {
-		this.rows = rows;
-		this.byPid = new Map(rows.map((row) => [row.pid, row]));
-	}
-	tree(rootPid) {
-		return processTree(this.rows, rootPid);
-	}
-	session(sessionId) {
-		return this.rows.flatMap((row) => row.session === sessionId ? [{
-			pid: row.pid,
-			started: row.started
-		}] : []);
-	}
-	alive(identity) {
-		const row = this.byPid.get(identity.pid);
-		return row?.started === identity.started && !quiescent(row.state);
-	}
-};
-function processTree(entries, rootPid) {
-	const root = new Map(entries.map((entry) => [entry.pid, entry])).get(rootPid);
-	if (root === void 0) return [];
-	const byParent = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const children = byParent.get(entry.parentPid) ?? [];
-		children.push(entry);
-		byParent.set(entry.parentPid, children);
-	}
-	const visited = /* @__PURE__ */ new Set();
-	const result = [];
-	const visit = (entry) => {
-		if (visited.has(entry.pid)) return;
-		visited.add(entry.pid);
-		for (const child of byParent.get(entry.pid) ?? []) visit(child);
-		result.push({
-			pid: entry.pid,
-			started: entry.started
+function directOutcome(child, files) {
+	return new Promise((resolveOutcome, rejectOutcome) => {
+		let settled = false;
+		child.once("error", (error) => {
+			if (settled) return;
+			settled = true;
+			rejectOutcome(error);
 		});
-	};
-	visit(root);
-	return result;
-}
-var LinuxProcessInspector = class extends PosixProcessInspector {
-	arch;
-	constructor(arch, internals) {
-		super(internals);
-		this.arch = arch;
-	}
-	foregroundPgid(shellPid) {
-		const tpgid = readLinuxStat(this.internals, shellPid)?.tpgid;
-		return tpgid !== void 0 && tpgid > 0 ? tpgid : void 0;
-	}
-	isStdinWaiting(pgid, shellPid) {
-		const tables = linuxSyscallTables(this.arch);
-		if (tables === void 0) return false;
-		const shell = readLinuxStat(this.internals, shellPid);
-		if (shell === void 0) return false;
-		const terminalDevice = readLinuxTerminalDevice(this.internals, shellPid, shell.ttyDevice);
-		if (terminalDevice === void 0) return false;
-		for (const pid of numericEntries(this.internals, "/proc")) {
-			const process = readLinuxStat(this.internals, pid);
-			if (process?.pgrp !== pgid) continue;
-			for (const tid of numericEntries(this.internals, `/proc/${pid}/task`)) {
-				const syscall = readSyscall(this.internals, pid, tid);
-				if (syscall !== void 0 && syscallWaitsOnStdin(this.internals, pid, tid, syscall, tables) && readLinuxTerminalDevice(this.internals, pid, process.ttyDevice, tid) === terminalDevice) return true;
+		child.once("exit", (exitCode, signal) => {
+			if (settled) return;
+			settled = true;
+			try {
+				const startup = readLinuxStartupError(files.startupErrorPath);
+				if (startup !== void 0) {
+					rejectOutcome(deserializeRunnerError(startup.error));
+					return;
+				}
+				if (existsSync(files.requestPath)) {
+					rejectOutcome(/* @__PURE__ */ new Error("subprocess scope exited before its bootstrap consumed the launch request"));
+					return;
+				}
+				resolveOutcome({
+					exitCode,
+					signal
+				});
+			} catch (error) {
+				rejectOutcome(error instanceof Error ? error : new Error(String(error)));
 			}
-		}
-		return false;
-	}
-	isAlive(identity) {
-		const stat = readLinuxStat(this.internals, identity.pid);
-		return stat?.started === identity.started && !quiescent(stat.state);
-	}
-	snapshot() {
-		return new PosixProcessSnapshot(numericEntries(this.internals, "/proc").flatMap((pid) => {
-			const stat = readLinuxStat(this.internals, pid);
-			return stat === void 0 ? [] : [{
-				pid,
-				parentPid: stat.parentPid,
-				started: stat.started,
-				session: stat.session,
-				state: stat.state
-			}];
-		}));
-	}
-};
-function macProcessTable(internals) {
-	return internals.exec("/bin/ps", ["-axo", "pid=,ppid=,lstart="]).split("\n").flatMap((line) => {
-		const match = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
-		if (match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0) return [];
-		return [{
-			pid: Number(match[1]),
-			parentPid: Number(match[2]),
-			started: match[3],
-			session: void 0,
-			state: void 0
-		}];
+		});
 	});
 }
-var MacProcessInspector = class extends PosixProcessInspector {
-	foregroundPgid(shellPid) {
+function signalChildGroup(child, signal) {
+	try {
+		process.kill(-child.pid, signal);
+	} catch {
 		try {
-			const value = Number(this.internals.exec("/bin/ps", [
-				"-o",
-				"tpgid=",
-				"-p",
-				String(shellPid)
-			]).trim());
-			return Number.isSafeInteger(value) && value > 0 ? value : void 0;
-		} catch (_missingProcess) {
-			return;
-		}
-	}
-	isStdinWaiting(_pgid, _shellPid) {
-		return false;
-	}
-	isAlive(identity) {
-		return macProcessTable(this.internals).some((entry) => entry.pid === identity.pid && entry.started === identity.started);
-	}
-	snapshot() {
-		return new PosixProcessSnapshot(macProcessTable(this.internals));
+			child.kill(signal);
+		} catch {}
 	}
-};
-/**
-* Create the supported platform inspector or fail at plugin load.
-* @param platform - target Node platform.
-* @param arch - target CPU architecture for Linux syscall numbers.
-* @param internals - filesystem/process boundary, injectable for deterministic tests.
-* @returns Platform process inspector.
-*/
-function createProcessInspector(platform = process.platform, arch = process.arch, internals = DEFAULT_INTERNALS) {
-	if (platform === "linux") return new LinuxProcessInspector(arch, internals);
-	if (platform === "darwin") return new MacProcessInspector(internals);
-	if (platform === "win32") return createWindowsProcessInspector();
-	throw new Error(`subprocess-local: terminal inspection is unsupported on platform ${platform}`);
 }
-//#endregion
-//#region lib/types/spawn.js
 /**
-* Process plumbing for the local subprocess service: detached process-tree
-* spawn with per-stream stdio dispositions, tail-keep collection with spill
-* files, tree-scoped signalling (POSIX groups; Windows taskkill), and the
-* SIGTERM→SIGKILL escalation. This layer reacts to an abort signal; callers
-* own deadlines, teardown ladders, and cause classification.
-* @module dsh-subprocess-local/spawn
+* Prepare one Linux PTY scope using the same launch request and bootstrap core.
+* @param spec - terminal target request.
+* @param targetEnv - validated complete target environment.
+* @param internals - optional runner and systemd seams used by tests.
+* @returns invocation facts and ownership callbacks for node-pty.
 */
-/**
-* Build a child environment: explicit caller entries override the scrubbed
-* parent base using the target platform's environment-key semantics. A string
-* deliberately restores or overrides an entry; an explicit `undefined`
-* tombstone removes an ordinary ambient entry.
-* @param extra - explicit caller entries and tombstones, merged after the scrub.
-* @returns the environment to hand to `spawn` for the child process.
-*/
-function childEnv(extra) {
-	const env = scrubbedParentEnv();
-	if (process.platform !== "win32") return {
-		...env,
-		...extra
+function prepareLinuxTerminalScope(spec, targetEnv, internals = {}) {
+	const invocation = internals.runnerInvocation ?? spawnRunnerInvocation();
+	const files = createLinuxLaunchFiles({
+		cwd: spec.cwd,
+		env: targetEnv
+	});
+	const unitBase = unitStem("dsh-terminal");
+	return {
+		command: internals.systemdRun ?? "systemd-run",
+		args: scopeArgs(unitBase, invocation, spec.argv),
+		cwd: process.cwd(),
+		env: runnerEnvironment(files.requestPath, invocation),
+		bindOwner: (direct) => new SystemdScopeOwner(`${unitBase}.scope`, files, direct, internals.systemctl ?? "systemctl", internals.spawnSync ?? spawnSync, internals.systemctlQuery ?? querySystemctl, internals.sleep ?? sleepWithAbort),
+		resolveOutcome: (outcome) => {
+			const startup = readLinuxStartupError(files.startupErrorPath);
+			if (startup !== void 0) throw deserializeRunnerError(startup.error);
+			if (existsSync(files.requestPath)) throw new Error("terminal scope exited before its bootstrap consumed the launch request");
+			return outcome;
+		},
+		cleanup: () => {
+			cleanupLinuxLaunchFiles(files);
+		}
 	};
-	let entries = Object.entries(env);
-	for (const [key, value] of Object.entries(extra ?? {})) {
-		const normalized = key.toUpperCase();
-		entries = entries.filter(([inherited]) => inherited.toUpperCase() !== normalized);
-		entries.push([key, value]);
-	}
-	return Object.fromEntries(entries);
 }
 /**
-* Liveness-poll cadence for tree-exit waits. The timer stays ref'd: an
-* awaited teardown must keep the event loop alive until the tree really
-* exits, or the parent can exit while claiming quiescence and orphan the
-* survivors it promised to reap.
+* Launch one ordinary target inside a transient user scope.
+* @param spec - ordinary target request.
+* @param targetEnv - validated complete target environment.
+* @param internals - optional runner and systemd seams used by tests.
+* @returns direct streams, result, and managed-scope owner.
 */
-function sleepTick() {
-	return setTimeout$1(15);
+function launchLinuxScope(spec, targetEnv, internals = {}) {
+	const invocation = internals.runnerInvocation ?? spawnRunnerInvocation();
+	const files = createLinuxLaunchFiles({
+		cwd: spec.cwd,
+		env: targetEnv
+	});
+	const unitBase = unitStem("dsh-subprocess");
+	let child;
+	try {
+		child = (internals.spawn ?? spawn)(internals.systemdRun ?? "systemd-run", scopeArgs(unitBase, invocation, spec.argv), {
+			cwd: process.cwd(),
+			env: runnerEnvironment(files.requestPath, invocation),
+			stdio: runnerStdio(spec, false),
+			detached: true
+		});
+	} catch (error) {
+		cleanupLinuxLaunchFiles(files);
+		throw error;
+	}
+	const owner = new SystemdScopeOwner(`${unitBase}.scope`, files, {
+		running: () => child.pid !== void 0 && child.exitCode === null && child.signalCode === null,
+		signal: (signal) => {
+			signalChildGroup(child, signal);
+		}
+	}, internals.systemctl ?? "systemctl", internals.spawnSync ?? spawnSync, internals.systemctlQuery ?? querySystemctl, internals.sleep ?? sleepWithAbort);
+	return {
+		stdin: child.stdin,
+		stdout: child.stdout,
+		stderr: child.stderr,
+		direct: directOutcome(child, files),
+		owner
+	};
 }
-let spillCounter = 0;
-let defaultSpillDir;
-/**
-* The default spill location: a private (0700) per-process directory under
-* the OS tmpdir, created lazily. Predictable world-readable paths would let
-* other local users read command output or pre-create symlinks.
-*/
-function privateSpillDir() {
-	defaultSpillDir ??= mkdtempSync(join(tmpdir(), "dsh-subprocess-"));
-	return defaultSpillDir;
+//#endregion
+//#region lib/types/windows-job.js
+/** Windows parent-side launch and ownership for the private Job runner. */
+function isWindowsStartCancellationError(error) {
+	return error.name === "Error" && error.message === "subprocess target start was cancelled" && error.code === void 0 && error.syscall === void 0 && error.path === void 0;
 }
 /**
-* Collects one stream with a bounded in-memory tail. With a spill cap, on
-* first overflow a spill file is created and every chunk (including those
-* already collected) is appended there while the full stream remains within
-* the cap; without one, only the in-memory tail is ever retained (the
-* diagnostic-tail shape — a language server's stderr).
-*
-* Tail-keep rationale (pi/OpenCode): errors and final results cluster at the
-* end of command output; the spill file covers the head.
+* Re-check the runner entry, bindings, and current Job capability for every spawn.
+* @param internals - optional runner and Win32 capability seams used by tests.
+* @returns whether the Windows native containment path is currently available.
 */
-var OutputCollector = class {
-	maxBytes;
-	maxSpillBytes;
-	label;
-	spillDir;
-	chunks = [];
-	bytes = 0;
-	dropped = false;
-	spillFd;
-	spillFile;
-	spillDisabled;
-	/** Total bytes ever pushed (not just retained). */
-	total = 0;
-	constructor(maxBytes, maxSpillBytes, label, spillDir) {
-		this.maxBytes = maxBytes;
-		this.maxSpillBytes = maxSpillBytes;
-		this.label = label;
-		this.spillDir = spillDir;
-		this.spillDisabled = maxSpillBytes === void 0;
-	}
-	/**
-	* Ingest one stream chunk, counting it toward the whole-stream total. On
-	* first overflow of the in-memory cap a spill file is opened (when spilling
-	* is enabled) and every chunk (already-collected ones included) is appended
-	* there from then on; the in-memory tail then drops whole chunks from its
-	* head (or the head of a single over-cap chunk) until it fits the cap again.
-	* @param chunk - the raw bytes from one stream 'data' event.
-	*/
-	push(chunk) {
-		this.total += chunk.length;
-		const overflows = this.bytes + chunk.length > this.maxBytes;
-		if (!this.spillDisabled && (overflows || this.spillFd !== void 0)) this.spillAll(chunk);
-		this.chunks.push(chunk);
-		this.bytes += chunk.length;
-		while (this.bytes > this.maxBytes) {
-			const head = this.chunks[0];
-			const excess = this.bytes - this.maxBytes;
-			if (head.length <= excess) {
-				this.chunks.shift();
-				this.bytes -= head.length;
-			} else {
-				this.chunks[0] = head.subarray(excess);
-				this.bytes -= excess;
-			}
-			this.dropped = true;
-		}
-	}
-	/** Open the spill file lazily and append `chunk` (and any prior chunks once). */
-	spillAll(chunk) {
-		if (this.maxSpillBytes !== void 0 && this.total > this.maxSpillBytes) {
-			this.discardSpill();
-			return;
-		}
-		if (this.spillFd === void 0) {
-			this.spillFile = join(this.spillDir, `dsh-subprocess-${process.pid}-${++spillCounter}-${randomBytes(6).toString("hex")}-${this.label}.log`);
-			this.spillFd = openSync(this.spillFile, "wx", 384);
-			for (const prior of this.chunks) writeSync(this.spillFd, prior);
-		}
-		writeSync(this.spillFd, chunk);
+function probeWindowsJob(internals = {}) {
+	try {
+		const invocation = internals.runnerInvocation ?? (internals.resolveRunnerInvocation ?? spawnRunnerInvocation)();
+		if (!(internals.runnerAvailable ?? runnerInvocationAvailable)(invocation)) return false;
+		const api = (internals.loadWin32ProcessBindings ?? loadWin32ProcessBindings)();
+		(internals.probeCurrentTokenJobSupport ?? probeCurrentTokenJobSupport)(api);
+		return true;
+	} catch {
+		return false;
 	}
-	/** Stop spilling and remove the file once it can no longer hold the complete stream. */
-	discardSpill() {
-		const fd = this.spillFd;
-		const file = this.spillFile;
-		this.spillFd = void 0;
-		this.spillFile = void 0;
-		this.spillDisabled = true;
-		if (fd !== void 0) try {
-			closeSync(fd);
-		} catch {
-			this.spillFd = fd;
+}
+var WindowsJobOwner = class {
+	runner;
+	exited;
+	directResultType;
+	failInfrastructure;
+	cancellationReason;
+	cancellationReasonSet = false;
+	terminationSent = false;
+	constructor(runner, exited, directResultType, failInfrastructure) {
+		this.runner = runner;
+		this.exited = exited;
+		this.directResultType = directResultType;
+		this.failInfrastructure = failInfrastructure;
+		this.exited.catch(() => {});
+	}
+	signal(_signal, cancellationReason) {
+		if (!this.cancellationReasonSet) {
+			this.cancellationReason = cancellationReason;
+			this.cancellationReasonSet = true;
 		}
-		if (file !== void 0) try {
-			unlinkSync(file);
-		} catch {}
-	}
-	/**
-	* Incremental read in whole-stream byte coordinates: returns everything
-	* pushed since `fromByte`. When `fromByte` has already slid out of the
-	* in-memory tail window, the read is `lossy` — it returns the whole
-	* retained tail and the gap is only recoverable from the spill file.
-	* @param fromByte - whole-stream offset to resume from (a prior read's `nextOffset`; 0 for the first read).
-	* @returns the delta text, the offset for the next read, the `lossy` flag, and the spill path when one was created.
-	*/
-	readFrom(fromByte) {
-		const windowStart = this.total - this.bytes;
-		const buffer = Buffer.concat(this.chunks);
-		const lossy = fromByte < windowStart;
-		return {
-			text: (lossy ? buffer : buffer.subarray(fromByte - windowStart)).toString("utf8"),
-			nextOffset: this.total,
-			lossy,
-			...this.spillFile !== void 0 ? { spillPath: this.spillFile } : {}
-		};
-	}
-	/**
-	* Close the spill file once the stream has ended. A failed close (delayed
-	* writeback fault) stops advertising the spill path — the file may be
-	* missing its tail — while every in-memory read keeps working. Idempotent;
-	* the spawn path seals both collectors at settlement so reads after exit
-	* never point at a still-open file.
-	*/
-	seal() {
-		if (this.spillFd === void 0) return;
+		if (this.terminationSent || !this.runner.connected) return;
+		this.terminationSent = true;
 		try {
-			closeSync(this.spillFd);
-		} catch {
-			this.spillFile = void 0;
+			this.runner.send?.({ type: "terminate" }, (error) => {
+				if (error === null || this.directResultType() !== void 0) return;
+				this.failInfrastructure(error);
+				this.terminateForHostExit();
+			});
+		} catch (error) {
+			this.failInfrastructure(error);
+			this.terminateForHostExit();
 		}
-		this.spillFd = void 0;
 	}
-	/**
-	* Seal the spill file and return the final output.
-	* @returns the final collected output: tail text, truncation flag, and the spill path when intact.
-	*/
-	finalize() {
-		this.seal();
-		return {
-			text: Buffer.concat(this.chunks).toString("utf8"),
-			truncated: this.dropped,
-			...this.spillFile !== void 0 ? { spillPath: this.spillFile } : {}
-		};
+	mapStartFailure(failure, serialized) {
+		return this.cancellationReasonSet && isWindowsStartCancellationError(serialized) ? this.cancellationReason : failure;
 	}
-};
-/**
-* Terminate one Windows process tree with `taskkill /T /F`. Contained like
-* POSIX group signalling — delivery races tree exit, so an absent tree, a
-* nonzero status, or a missing taskkill binary must not break idempotent
-* teardown.
-* @param pid - root process id; non-positive is a no-op.
-*/
-function taskkillProcessTree(pid) {
-	if (pid <= 0) return;
-	spawnSync("taskkill", [
-		"/PID",
-		String(pid),
-		"/T",
-		"/F"
-	], { stdio: "ignore" });
-}
-/**
-* Signal a detached process tree with platform-correct semantics: POSIX
-* signals the negative process-group id and falls back to the direct child
-* when the group is gone; Windows terminates the tree via taskkill (any
-* signal value force-terminates — Node maps signals to TerminateProcess).
-*/
-function signalTree(platform, pid, sig, child, taskkill) {
-	if (platform === "win32") {
-		taskkill(pid);
-		return;
+	async waitForExit() {
+		await this.exited;
 	}
-	/* v8 ignore next -- kill/terminate gate on treeAlive(), which is false for pid -1; this guard protects direct callers only. */
-	if (pid <= 0) return;
-	try {
-		process.kill(-pid, sig);
-	} catch {
-		/* v8 ignore start -- the fallback needs a live child whose group signal fails
-		(EPERM-style), which POSIX CI cannot stage; the swallow keeps teardown idempotent. */
+	terminateForHostExit() {
 		try {
-			child.kill(sig);
+			this.runner.kill("SIGKILL");
 		} catch {}
 	}
-}
+};
 /**
-* Spawn one isolated detached process tree with the spec's per-stream stdio
-* dispositions. Runtime exits resolve `done` as {@link SubprocessOutcome};
-* only spawn failures reject.
-* @param spec - fully resolved argv, cwd, stdio, grace, cancellation, environment.
-* @param internals - test-only spill-directory, platform, and taskkill overrides.
-* @returns live subprocess handle.
-* @throws when `graceMs` cannot be represented by one Node timer.
+* Launch one target through a runner that uniquely owns its Job handle.
+* @param spec - ordinary target request.
+* @param targetEnv - validated complete target environment.
+* @param internals - optional runner launch seams used by tests.
+* @returns direct streams, result, and runner-owned managed range.
 */
-function spawnSubprocess(spec, internals = {}) {
-	if (!Number.isFinite(spec.graceMs) || spec.graceMs <= 0 || spec.graceMs > MAX_TIMER_DELAY_MS) throw new Error(`subprocess graceMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
-	const spillDir = internals.spillDir ?? privateSpillDir();
-	const platform = internals.platform ?? process.platform;
-	const taskkill = internals.taskkill ?? taskkillProcessTree;
-	const linuxGroupHasLiveMembers = internals.linuxProcessGroupHasLiveMembers ?? linuxProcessGroupHasLiveMembers;
-	if (spec.signal?.aborted) throw new Error(`aborted before spawn: ${String(spec.signal.reason ?? "aborted")}`);
-	const [program, ...args] = spec.argv;
-	if (program === void 0 || program.length === 0) throw new Error("invalid argv: expected a non-empty program name at argv[0]");
-	const isCollect = (mode) => mode !== "pipe" && mode !== "inherit";
-	const outMode = spec.stdio.stdout;
-	const errMode = spec.stdio.stderr;
-	const stdinMode = spec.stdio.stdin;
-	const env = childEnv(spec.env);
-	const child = spawn(program, args, {
-		cwd: spec.cwd,
-		env,
-		stdio: [
-			stdinMode === "ignore" ? "ignore" : "pipe",
-			outMode === "inherit" ? "inherit" : "pipe",
-			errMode === "inherit" ? "inherit" : "pipe"
-		],
-		detached: platform !== "win32"
-	});
-	const collectStream = (mode, stream, label) => {
-		if (!isCollect(mode) || stream === null) return void 0;
-		const collector = new OutputCollector(mode.maxBytes, mode.spill?.maxBytes, label, spillDir);
-		stream.on("data", (chunk) => {
-			collector.push(chunk);
+function launchWindowsJob(spec, targetEnv, internals = {}) {
+	const invocation = internals.runnerInvocation ?? spawnRunnerInvocation();
+	const [command, ...prefix] = invocation;
+	const ignoredStdinFd = spec.stdio.stdin === "ignore" ? openSync(devNull, "r") : void 0;
+	let child;
+	try {
+		child = (internals.spawn ?? spawn)(command, [
+			...prefix,
+			"--",
+			...spec.argv
+		], {
+			cwd: process.cwd(),
+			env: runnerEnvironment(WINDOWS_RUNNER_SELECTION, invocation),
+			stdio: runnerStdio(spec, true, ignoredStdinFd ?? "pipe")
 		});
-		return collector;
+	} finally {
+		if (ignoredStdinFd !== void 0) closeSync(ignoredStdinFd);
+	}
+	const targetStdin = child.stdio[4];
+	const direct = Promise.withResolvers();
+	const rangeExit = Promise.withResolvers();
+	let directResultType;
+	let runnerSpawned = false;
+	const failInfrastructure = (error) => {
+		direct.reject(error);
+		rangeExit.reject(error);
 	};
-	const stdoutCollector = collectStream(outMode, child.stdout, "stdout");
-	const stderrCollector = collectStream(errMode, child.stderr, "stderr");
-	let graceTimer;
-	let treeExitObserved = false;
-	let treeExitObservation;
-	let settled = false;
-	const pid = child.pid ?? -1;
-	/** Whether the detached tree's root (or POSIX group) is still alive. */
-	const treeAlive = () => {
-		/* v8 ignore next -- only a timer callback already queued when the observer settles can enter here;
-		the guard is the final defense against probing an id after its tree was confirmed absent. */
-		if (treeExitObserved) return false;
-		if (pid <= 0) return false;
-		if (platform === "win32") return child.exitCode === null && child.signalCode === null;
+	const owner = new WindowsJobOwner(child, rangeExit.promise, () => directResultType, failInfrastructure);
+	child.on("message", (value) => {
+		if (directResultType !== void 0) {
+			failInfrastructure(/* @__PURE__ */ new Error("subprocess-local: Windows runner emitted more than one direct result"));
+			owner.terminateForHostExit();
+			return;
+		}
+		let result;
 		try {
-			process.kill(-pid, 0);
-			if (settled && platform === "linux" && linuxGroupHasLiveMembers(pid) === false) return false;
-			return true;
+			result = parseWindowsRunnerResult(value);
 		} catch (error) {
-			const code = error.code;
-			/* v8 ignore next 2 -- POSIX reports an absent group as ESRCH; child-reaping timing
-			makes observing the other arm platform-dependent. */
-			if (code === "ESRCH") return false;
-			/* v8 ignore start -- EPERM and non-POSIX negative-pid failures are platform defenses; CI runs
-			tree-lifecycle tests on POSIX hosts where absence reports ESRCH. */
-			if (code === "EPERM") return true;
-			return child.exitCode === null && child.signalCode === null;
+			failInfrastructure(error);
+			owner.terminateForHostExit();
+			return;
 		}
-	};
-	/**
-	* Start or reuse the handle's single whole-tree exit observer. The first
-	* confirmed absence is a permanent no-more-signals boundary: it cancels a
-	* pending escalation before this process-group id can be reused.
-	*/
-	const observeTreeExit = () => {
-		treeExitObservation ??= (async () => {
-			while (treeAlive()) await sleepTick();
-			treeExitObserved = true;
-			if (graceTimer !== void 0) clearTimeout(graceTimer);
-			graceTimer = void 0;
-		})();
-		return treeExitObservation;
-	};
-	const kill = (sig) => {
-		/* v8 ignore next -- the shared exit observer cancels the ordinary dead-tree timer;
-		this remains the timer/death race guard and cannot be staged deterministically. */
-		if (!treeAlive()) return;
-		signalTree(platform, pid, sig, child, taskkill);
-	};
-	const terminate = () => {
-		if (treeExitObserved || graceTimer !== void 0) return;
-		observeTreeExit();
-		if (treeExitObserved) return;
-		kill("SIGTERM");
-		graceTimer = setTimeout(() => {
-			kill("SIGKILL");
-		}, spec.graceMs);
-	};
-	const terminateForHostExit = () => {
-		kill("SIGKILL");
-	};
-	const onAbort = () => {
-		terminate();
-	};
-	spec.signal?.addEventListener("abort", onAbort, { once: true });
-	if (typeof stdinMode === "object" && child.stdin !== null) {
-		child.stdin.on("error", () => {});
-		child.stdin.end(stdinMode.data);
-	}
-	const done = new Promise((resolve, reject) => {
-		let pipeDrainTimer;
-		const settle = (exitCode, signal) => {
-			if (settled) return;
-			settled = true;
-			if (stdoutCollector !== void 0) child.stdout?.destroy();
-			if (stderrCollector !== void 0) child.stderr?.destroy();
-			stdoutCollector?.seal();
-			stderrCollector?.seal();
-			cleanup();
-			resolve({
-				exitCode,
-				signal
-			});
-		};
-		child.on("error", (error) => {
-			settled = true;
-			cleanup();
-			reject(error);
-		});
-		child.on("exit", (exitCode, signal) => {
-			pipeDrainTimer = setTimeout(() => {
-				settle(exitCode, signal);
-			}, spec.graceMs);
+		directResultType = result.type;
+		if (result.type === "target-exit") direct.resolve({
+			exitCode: result.exitCode,
+			signal: null
 		});
-		child.on("close", settle);
-		function cleanup() {
-			if (pipeDrainTimer !== void 0) clearTimeout(pipeDrainTimer);
-			spec.signal?.removeEventListener("abort", onAbort);
+		else direct.reject(owner.mapStartFailure(deserializeRunnerError(result.error), result.error));
+	});
+	child.once("spawn", () => {
+		runnerSpawned = true;
+		try {
+			if (child.send === void 0) throw new Error("subprocess-local: Windows runner has no IPC channel");
+			child.send({
+				type: "start",
+				cwd: spec.cwd,
+				env: targetEnv
+			}, (error) => {
+				if (error === null) return;
+				failInfrastructure(error);
+				owner.terminateForHostExit();
+			});
+		} catch (error) {
+			failInfrastructure(error);
+			owner.terminateForHostExit();
 		}
 	});
-	const waitForExit = async (signal) => {
-		const observed = observeTreeExit();
-		if (treeExitObserved) return true;
-		if (signal?.aborted) return false;
-		if (signal === void 0) {
-			await observed;
-			return true;
+	child.once("error", (error) => {
+		if (!runnerSpawned) {
+			direct.reject(error);
+			rangeExit.resolve();
+			return;
 		}
-		const aborted = Promise.withResolvers();
-		const onAbort = () => {
-			aborted.resolve(false);
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		/* v8 ignore next -- closes the event-loop race between the preceding aborted check and listener registration. */
-		if (signal.aborted) onAbort();
-		try {
-			return await Promise.race([observed.then(() => true), aborted.promise]);
-		} finally {
-			signal.removeEventListener("abort", onAbort);
+		failInfrastructure(error);
+	});
+	child.once("close", (exitCode, signal) => {
+		if (!runnerSpawned) return;
+		if (exitCode === 0 && signal === null && directResultType !== void 0) {
+			rangeExit.resolve();
+			return;
 		}
-	};
+		const status = signal !== null ? `signal ${signal}` : exitCode === null ? "without an exit status" : `exit code ${String(exitCode)}`;
+		failInfrastructure(/* @__PURE__ */ new Error(`subprocess-local: Windows Job runner exited with ${status} before proving its managed range empty`));
+	});
 	return {
-		pid,
-		/* v8 ignore start -- pipe-mode fds exist on every spawn Node returns; the null-coalesces guard a nonconforming ChildProcess only. */
-		stdin: stdinMode === "pipe" ? child.stdin ?? void 0 : void 0,
-		stdout: outMode === "pipe" ? child.stdout ?? void 0 : void 0,
-		stderr: errMode === "pipe" ? child.stderr ?? void 0 : void 0,
-		/* v8 ignore stop */
-		collected: {
-			...stdoutCollector !== void 0 ? { stdout: stdoutCollector } : {},
-			...stderrCollector !== void 0 ? { stderr: stderrCollector } : {}
-		},
-		done,
-		terminate,
-		terminateForHostExit,
-		waitForExit
+		stdin: spec.stdio.stdin === "ignore" ? null : targetStdin,
+		stdout: child.stdio[5],
+		stderr: child.stdio[6],
+		direct: direct.promise,
+		owner
 	};
 }
 //#endregion
 //#region lib/types/terminal.js
 /** Local node-pty terminal-process implementation for the subprocess seam. */
-function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+	return new Promise((resolve) => {
+		const finish = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", finish);
+			resolve();
+		};
+		const timer = setTimeout(finish, ms);
+		signal?.addEventListener("abort", finish, { once: true });
+	});
+}
+async function raceWithDelay(operation, ms, timeout) {
+	const controller = new AbortController();
+	try {
+		return await Promise.race([operation, delay(ms, controller.signal).then(() => timeout)]);
+	} finally {
+		controller.abort();
+	}
 }
 function signalName(number) {
 	if (number === void 0 || number === 0) return null;
@@ -1013,7 +610,8 @@ function signalName(number) {
 	return null;
 }
 /**
-* A local terminal whose process-session ownership stays below the PTY backend.
+* A local terminal whose native managed range or fallback process-session
+* ownership stays below the PTY backend.
 * The seam's terminate() promise — no write, inspection, or signal in flight
 * after settlement — holds here without operation tracking only because every
 * handle call completes synchronously under the hood (node-pty write, ps-based
@@ -1025,6 +623,8 @@ var LocalTerminalHandle = class {
 	inspector;
 	graceMs;
 	platform;
+	managedOwner;
+	resolveManagedOutcome;
 	pid;
 	output = new PassThrough();
 	done;
@@ -1032,6 +632,7 @@ var LocalTerminalHandle = class {
 	dataDisposable;
 	exitDisposable;
 	cleanup;
+	managedOwnerCleaned = false;
 	exited = false;
 	trackedDescendants = [];
 	/** The spawned shell's start identity; scans stop adopting members once the root pid no longer carries it. */
@@ -1042,27 +643,38 @@ var LocalTerminalHandle = class {
 	* @param graceMs - TERM-to-KILL and exit-wait grace.
 	* @param platform - host platform; defaults to the running platform, injectable for deterministic tests.
 	*/
-	constructor(terminal, inspector, graceMs, platform = process.platform) {
+	constructor(terminal, inspector, graceMs, platform = process.platform, managedOwner, resolveManagedOutcome) {
 		this.terminal = terminal;
 		this.inspector = inspector;
 		this.graceMs = graceMs;
 		this.platform = platform;
+		this.managedOwner = managedOwner;
+		this.resolveManagedOutcome = resolveManagedOutcome;
 		this.pid = terminal.pid;
 		this.rootIdentity = inspector.snapshot().tree(this.pid).find((member) => member.pid === this.pid);
 		this.done = this.outcome.promise;
 		this.dataDisposable = terminal.onData((data) => {
-			this.output.write(Buffer$1.from(data, "utf8"));
+			this.output.write(Buffer.from(data, "utf8"));
 		});
 		this.exitDisposable = terminal.onExit(({ exitCode, signal: exitSignal }) => {
 			if (this.exited) return;
 			this.exited = true;
 			this.output.end();
-			this.outcome.resolve({
+			const outcome = {
 				exitCode: exitSignal === void 0 || exitSignal === 0 ? exitCode : null,
 				signal: signalName(exitSignal)
-			});
+			};
+			try {
+				this.outcome.resolve(this.resolveManagedOutcome?.(outcome) ?? outcome);
+			} catch (error) {
+				this.outcome.reject(error);
+			}
 		});
 	}
+	/** Whether node-pty has not yet published the top-level exit event. */
+	get running() {
+		return !this.exited;
+	}
 	async write(data) {
 		if (this.exited) throw new Error("terminal process has exited");
 		this.terminal.write(data);
@@ -1107,6 +719,7 @@ var LocalTerminalHandle = class {
 		this.forceStopDescendants();
 		this.forceStopShell();
 		this.forceStopDescendants();
+		this.managedOwner?.terminateForHostExit();
 	}
 	forceStopShell() {
 		if (this.exited) return;
@@ -1218,6 +831,18 @@ var LocalTerminalHandle = class {
 		}
 	}
 	async closeOnce() {
+		if (this.managedOwner !== void 0) {
+			try {
+				await this.closeManagedRange(this.managedOwner);
+				this.dataDisposable.dispose();
+				this.exitDisposable.dispose();
+			} finally {
+				this.done.finally(() => {
+					this.cleanupManagedOwner(this.managedOwner);
+				}).catch(() => {});
+			}
+			return;
+		}
 		let survivors = await this.stopDescendants();
 		if (survivors.length > 0) throw new Error(`terminal cleanup failed; surviving pids: ${survivors.map((member) => member.pid).join(", ")}`);
 		await this.stopShell();
@@ -1227,6 +852,33 @@ var LocalTerminalHandle = class {
 		this.dataDisposable.dispose();
 		this.exitDisposable.dispose();
 	}
+	cleanupManagedOwner(owner) {
+		if (this.managedOwnerCleaned) return;
+		this.managedOwnerCleaned = true;
+		owner.cleanup?.();
+	}
+	async closeManagedRange(owner) {
+		owner.signal("SIGTERM");
+		const observation = owner.waitForExit();
+		const first = await raceWithDelay(observation.then(() => ({ kind: "stopped" }), (error) => ({
+			kind: "failed",
+			error
+		})), this.graceMs, { kind: "timeout" });
+		if (first.kind !== "stopped") {
+			owner.signal("SIGKILL");
+			if (first.kind === "failed") {
+				try {
+					await owner.waitForExit();
+				} catch (finalError) {
+					throw new AggregateError([first.error, finalError], "terminal managed-range cleanup failed");
+				}
+				throw first.error;
+			}
+			await observation;
+		}
+		if (!this.exited) await raceWithDelay(this.done.then(() => void 0), this.graceMs, void 0);
+		if (!this.exited) throw new Error(`terminal cleanup failed; surviving pid: ${this.pid}`);
+	}
 	settleExitIfGone() {
 		if (this.platform !== "win32") return;
 		if (this.exited) return;
@@ -1244,28 +896,32 @@ var LocalTerminalHandle = class {
 //#endregion
 //#region lib/types/index.js
 /**
-* Local Service Provider for the subprocess capability seam. Each spawn is a detached
-* process tree with the spec's per-stream stdio dispositions. Normal disposal
-* terminates and joins live trees; Node's synchronous exit phase force-stops
-* any trees the service still owns. It has no config: every disposition and
-* limit arrives on the spec, so the deployment-varying choices stay with the
-* caller's config (the bash executor's, the LSP host's, …).
+* Local Service Provider for the subprocess capability seam. Each spawn owns a
+* platform-selected managed range with the spec's per-stream stdio dispositions.
+* Normal disposal terminates and joins live ranges; Node's synchronous exit
+* phase force-stops any ranges the service still owns. It has no config: every
+* disposition and limit arrives on the spec, so deployment-varying choices
+* stay with the caller's config (the bash executor's, the LSP host's, …).
 * @module @deepseek-ai/dsh-subprocess-local
 */
 /**
-* Local subprocess service: detached process trees, Node-shaped stdio
+* Local subprocess service: platform-selected managed ranges, Node-shaped stdio
 * dispositions (raw pipes, inherit, bounded tail-keep collection with spill
-* files), credential-scrubbed environment, and tree-scoped signalling with
-* SIGTERM→grace→SIGKILL escalation, plus synchronous final termination during
-* JavaScript-observable host exit.
+* files), credential-scrubbed environment, and provider-owned range signalling.
+* POSIX paths stage TERM before KILL; Windows paths terminate immediately.
+* JavaScript-observable host exit also performs synchronous final termination.
 */
 var LocalSubprocessRuntime = class extends SubprocessRuntime {
 	/** Live handles retained for normal disposal and synchronous host-exit finalization. */
 	live = /* @__PURE__ */ new Set();
 	/** Live terminals retained through normal quiescence or host-exit finalization. */
 	terminals = /* @__PURE__ */ new Set();
-	/** Test hook: spill and platform knobs forwarded to spawnSubprocess. */
+	/** Test hook: process, spill, and platform operations forwarded to spawnSubprocess. */
 	internals = {};
+	/** Provider-lifetime latch suppressing repeated weaker-containment warnings. */
+	fallbackWarningIssued = false;
+	/** Positive-only cache for the expensive Linux bootstrap and scope probe. */
+	linuxDeepProbePassed = false;
 	/** Test hook for platform process inspection; production resolves lazily on terminal spawn. */
 	terminalInspector;
 	constructor(ctx) {
@@ -1276,18 +932,15 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 			};
 			process.prependListener("exit", onHostExit);
 			return async () => {
-				try {
-					await this.disposeManagedProcesses();
-				} finally {
-					process.off("exit", onHostExit);
-				}
+				await this.disposeManagedProcesses();
+				process.off("exit", onHostExit);
 			};
 		}, "local subprocess teardown");
 	}
 	terminateForHostExit() {
 		for (const handle of this.live) try {
 			handle.terminateForHostExit();
-		} catch (_ordinaryTreeTerminationFailed) {}
+		} catch (_ordinaryRangeTerminationFailed) {}
 		for (const terminal of this.terminals) try {
 			terminal.terminateForHostExit();
 		} catch (_terminalTerminationFailed) {}
@@ -1296,13 +949,17 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 		const pending = [];
 		for (const handle of this.live) {
 			handle.terminate();
-			pending.push(handle.done.catch(() => {}).then(() => handle.waitForExit()));
+			pending.push(Promise.all([handle.done.catch(() => {}), handle.waitForExit()]).then(() => {
+				this.live.delete(handle);
+			}));
 		}
-		for (const terminal of this.terminals) pending.push(terminal.terminate());
-		const failures = (await Promise.allSettled(pending)).flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+		for (const terminal of this.terminals) pending.push(terminal.terminate().then(() => {
+			this.terminals.delete(terminal);
+		}));
+		const outcomes = await Promise.allSettled(pending);
+		const failures = [];
+		for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
 		if (failures.length > 0) this.terminateForHostExit();
-		this.live.clear();
-		this.terminals.clear();
 		if (failures.length === 1) throw failures[0];
 		if (failures.length > 1) throw new AggregateError(failures, "local subprocess teardown failed");
 	}
@@ -1331,27 +988,82 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 		return path.split(delimiter).flatMap((directory) => extensions.map((extension) => resolve(process.cwd(), directory, command + extension)));
 	}
 	spawn(spec) {
-		const handle = spawnSubprocess(spec, this.internals);
+		validateSubprocessSpec(spec);
+		const env = targetEnvironment(spec);
+		const containmentMode = this.selectContainmentMode("ordinary");
+		let handle;
+		if (containmentMode === "fallback") handle = spawnSubprocess(spec, this.internals);
+		else {
+			const binding = prepareManagedProcessBinding(this.internals);
+			handle = bindManagedProcess(spec, containmentMode === "linux-scope" ? launchLinuxScope(spec, env) : launchWindowsJob(spec, env), binding);
+		}
 		this.live.add(handle);
 		const release = () => handle.waitForExit().then(() => {
 			this.live.delete(handle);
 		});
-		handle.done.then(release, release);
+		handle.done.then(release, release).catch(() => {});
 		return handle;
 	}
+	selectContainmentMode(kind) {
+		const platform = this.internals.platform ?? process.platform;
+		let fallbackReason;
+		if (platform === "linux") {
+			const available = this.linuxDeepProbePassed ? probeLinuxManager() : probeLinuxNative();
+			if (available) this.linuxDeepProbePassed = true;
+			if (available) return "linux-scope";
+			fallbackReason = "the current user-systemd scope or private bootstrap is unavailable";
+		}
+		if (kind === "ordinary" && platform === "win32") {
+			if (probeWindowsJob()) return "windows-job";
+		}
+		this.warnFallback(platform, kind, fallbackReason);
+		return "fallback";
+	}
+	warnFallback(platform, kind, selectedReason) {
+		if (this.fallbackWarningIssued) return;
+		this.fallbackWarningIssued = true;
+		const reason = selectedReason ?? (platform === "darwin" ? "macOS has no supported persistent process-range owner" : platform === "win32" ? kind === "terminal" ? "Windows ConPTY remains outside Job containment" : "the Win32 Job runner is unavailable" : `platform ${platform} has no native managed range`);
+		this.ctx.logger.warn(`subprocess-local is using weaker process-tree containment because ${reason}; descendants that escape the process group or direct-parent tree are not guaranteed to terminate or delay waitForExit()`);
+	}
 	async spawnTerminal(spec) {
 		const file = spec.argv[0];
 		if (file === void 0 || file.length === 0) throw new Error("subprocess-local: terminal argv must contain a program");
 		spec.signal?.throwIfAborted();
+		const env = targetEnvironment(spec);
 		const options = {
 			name: "dumb",
 			rows: spec.rows,
 			cols: spec.cols,
 			cwd: spec.cwd,
-			env: childEnv(spec.env)
+			env
 		};
 		const inspector = this.terminalInspector ?? createProcessInspector();
-		const handle = new LocalTerminalHandle(nodePty.spawn(file, [...spec.argv.slice(1)], options), inspector, spec.graceMs);
+		const scope = this.selectContainmentMode("terminal") === "linux-scope" ? prepareLinuxTerminalScope(spec, {
+			...env,
+			PWD: spec.cwd,
+			TERM: "dumb"
+		}) : void 0;
+		if (scope !== void 0) {
+			options.cwd = scope.cwd;
+			options.env = scope.env;
+		}
+		let terminal;
+		try {
+			terminal = nodePty.spawn(scope?.command ?? file, scope?.args ?? [...spec.argv.slice(1)], options);
+		} catch (error) {
+			scope?.cleanup();
+			throw error;
+		}
+		let handle;
+		const owner = scope?.bindOwner({
+			running: () => handle?.running ?? true,
+			signal: (signal) => {
+				try {
+					terminal.kill(signal);
+				} catch {}
+			}
+		});
+		handle = new LocalTerminalHandle(terminal, inspector, spec.graceMs, this.internals.platform ?? process.platform, owner, scope?.resolveOutcome);
 		this.terminals.add(handle);
 		const release = async () => {
 			await handle.terminate();