@deepseek-ai/dsh-subprocess-local 0.1.5-rc.2 → 0.1.6-alpha.1

package/lib/index.js

@@ -1,13 +1,14 @@
-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 { C as bindManagedProcess, D as createProcessInspector, E as validateSubprocessSpec, O as controlPipe, S as loadLinuxExecve, T as spawnSubprocess, _ 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-BnjugUhn.js";
+import { prepareManagedProcessBinding } from "./output.js";
 import { closeSync, constants, existsSync, openSync } from "node:fs";
 import { access, stat } from "node:fs/promises";
+import { constants as constants$1, devNull, userInfo } from "node:os";
 import { delimiter, extname, isAbsolute, resolve } from "node:path";
 import * as nodePty from "node-pty";
-import { SubprocessRuntime } from "@deepseek-ai/dsh-subprocess";
+import { SubprocessExecutableNotFoundError, SubprocessRuntime } from "@deepseek-ai/dsh-subprocess";
 import { execFile, spawn, spawnSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { constants as constants$1, devNull } from "node:os";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { randomBytes } from "node:crypto";
 import { loadWin32ProcessBindings, probeCurrentTokenJobSupport } from "@deepseek-ai/dsh-win32-process";
 import { Buffer } from "node:buffer";
 import { PassThrough } from "node:stream";
@@ -118,9 +119,24 @@ function probeLinuxManager(internals = {}) {
 function probeLinuxNative(internals = {}) {
 	return probeLinuxBootstrap(internals) && probeLinuxScope(internals);
 }
+var LinuxScopeStartup = class {
+	files;
+	kind;
+	terminationSignals = /* @__PURE__ */ new Set();
+	constructor(files, kind) {
+		this.files = files;
+		this.kind = kind;
+	}
+	resolveOutcome(outcome) {
+		const startup = readLinuxStartupError(this.files.startupErrorPath);
+		if (startup !== void 0) throw deserializeRunnerError(startup.error);
+		if (existsSync(this.files.requestPath) && !(outcome.signal !== null && this.terminationSignals.has(outcome.signal))) throw new Error(`${this.kind} scope exited before its bootstrap consumed the launch request`);
+		return outcome;
+	}
+};
 var SystemdScopeOwner = class {
 	unit;
-	files;
+	startup;
 	direct;
 	systemctl;
 	runSync;
@@ -128,13 +144,15 @@ var SystemdScopeOwner = class {
 	sleep;
 	establishment = "pending";
 	stopped = false;
+	terminationRequested = false;
 	observation;
 	killFailure;
+	directKillSettlement;
 	wakeGeneration = 0;
 	wakeWaiter;
-	constructor(unit, files, direct, systemctl, runSync, query, sleep) {
+	constructor(unit, startup, direct, systemctl, runSync, query, sleep) {
 		this.unit = unit;
-		this.files = files;
+		this.startup = startup;
 		this.direct = direct;
 		this.systemctl = systemctl;
 		this.runSync = runSync;
@@ -143,9 +161,12 @@ var SystemdScopeOwner = class {
 	}
 	signal(signal) {
 		if (this.stopped) return;
+		this.terminationRequested = true;
+		if (this.direct.running()) this.startup.terminationSignals.add(signal);
 		this.observeRequestConsumption();
 		const directFallbackRequired = this.establishment === "pending";
-		if (directFallbackRequired && this.direct.running()) this.direct.signal(signal);
+		let directSignalled = false;
+		if (directFallbackRequired && this.direct.running()) directSignalled = this.direct.signal(signal);
 		const result = this.runSync(this.systemctl, [
 			"--user",
 			"kill",
@@ -159,13 +180,19 @@ var SystemdScopeOwner = class {
 		});
 		this.wakeObservation();
 		if (result.error === void 0 && result.status === 0) {
-			if (signal === "SIGKILL") this.killFailure = void 0;
+			if (signal === "SIGKILL") {
+				this.killFailure = void 0;
+				this.directKillSettlement = void 0;
+			}
 			return;
 		}
-		if (!directFallbackRequired && this.direct.running()) this.direct.signal(signal);
+		if (!directFallbackRequired && this.direct.running()) directSignalled = 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)}`}`);
+			if (!MISSING_UNIT.test(output)) {
+				this.killFailure = result.error ?? /* @__PURE__ */ new Error(`systemctl could not signal ${this.unit}: ${output.trim() || `exit ${String(result.status)}`}`);
+				this.directKillSettlement = directSignalled ? this.direct.settled.then(() => {}, () => {}) : void 0;
+			}
 		}
 	}
 	terminateForHostExit() {
@@ -188,15 +215,40 @@ var SystemdScopeOwner = class {
 		} catch {}
 	}
 	observeRequestConsumption() {
-		if (this.establishment === "pending" && !existsSync(this.files.requestPath)) this.establishment = "established";
+		if (this.establishment === "pending" && !existsSync(this.startup.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.direct.running() && existsSync(this.startup.files.requestPath)) return false;
 		if (this.killFailure !== void 0) throw this.killFailure;
 		return true;
 	}
+	/**
+	* Prove an active unit with no processes is the empty managed range rather
+	* than a launch still placing its payload. systemd ends a scope only on the
+	* populated-to-empty transition, so a payload killed before it entered the
+	* cgroup leaves the unit active forever. A departed client cannot add another
+	* payload; a consumed request proves the payload already entered the scope,
+	* even while its direct-process exit notification is pending.
+	*/
+	emptyRange(tasksCurrent) {
+		return this.terminationRequested && tasksCurrent === 0 && (!this.direct.running() || !existsSync(this.startup.files.requestPath));
+	}
+	/** Release a leftover empty scope so the transient unit is collected and cannot accumulate. */
+	releaseEmptyRange() {
+		try {
+			this.runSync(this.systemctl, [
+				"--user",
+				"stop",
+				this.unit
+			], {
+				env: managerEnvironment(),
+				stdio: "ignore",
+				timeout: SYSTEMCTL_TIMEOUT_MS
+			});
+		} catch {}
+	}
 	parseUnitState(stdout) {
 		const values = /* @__PURE__ */ new Map();
 		for (const line of stdout.split(/\r?\n/u)) {
@@ -209,24 +261,32 @@ var SystemdScopeOwner = class {
 		}
 		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())}`);
+		const reportedTasks = values.get("TasksCurrent");
+		const tasksCurrent = reportedTasks === "[not set]" ? void 0 : reportedTasks;
+		if (values.size !== (reportedTasks === void 0 ? 2 : 3) || loadState === void 0 || activeState === void 0) throw new Error(`systemctl returned incomplete state for ${this.unit}: ${JSON.stringify(stdout.trim())}`);
+		if (tasksCurrent !== void 0 && !/^\d+$/u.test(tasksCurrent)) throw new Error(`systemctl returned a non-numeric TasksCurrent for ${this.unit}: ${JSON.stringify(tasksCurrent)}`);
 		return {
 			loadState,
-			activeState
+			activeState,
+			tasksCurrent: tasksCurrent === void 0 ? void 0 : Number(tasksCurrent)
 		};
 	}
 	async rangeActive() {
 		this.observeRequestConsumption();
+		const generation = this.wakeGeneration;
+		const directRunning = this.direct.running();
 		const result = await this.query(this.systemctl, [
 			"--user",
 			"show",
 			this.unit,
 			"--property=LoadState",
-			"--property=ActiveState"
+			"--property=ActiveState",
+			"--property=TasksCurrent"
 		]);
+		if (generation !== this.wakeGeneration) return true;
 		const output = `${result.stdout}\n${result.stderr}`;
 		if (result.status === 0) {
-			const { loadState, activeState } = this.parseUnitState(result.stdout);
+			const { loadState, activeState, tasksCurrent } = 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,
@@ -240,7 +300,19 @@ var SystemdScopeOwner = class {
 				"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;
+			if (this.emptyRange(tasksCurrent)) {
+				this.releaseEmptyRange();
+				return false;
+			}
+			if (this.killFailure !== void 0) {
+				if (directRunning && this.directKillSettlement !== void 0) {
+					const settlement = this.directKillSettlement;
+					this.directKillSettlement = void 0;
+					await settlement;
+					return this.rangeActive();
+				}
+				throw this.killFailure;
+			}
 			return true;
 		}
 		if (!MISSING_UNIT.test(output)) {
@@ -288,7 +360,7 @@ var SystemdScopeOwner = class {
 		await this.observation;
 	}
 	cleanup() {
-		cleanupLinuxLaunchFiles(this.files);
+		cleanupLinuxLaunchFiles(this.startup.files);
 	}
 };
 function scopeArgs(unitBase, invocation, argv) {
@@ -305,7 +377,7 @@ function scopeArgs(unitBase, invocation, argv) {
 		...argv
 	];
 }
-function directOutcome(child, files) {
+function directOutcome(child, startup) {
 	return new Promise((resolveOutcome, rejectOutcome) => {
 		let settled = false;
 		child.once("error", (error) => {
@@ -317,40 +389,47 @@ function directOutcome(child, files) {
 			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({
+				resolveOutcome(startup.resolveOutcome({
 					exitCode,
 					signal
-				});
+				}));
 			} catch (error) {
 				rejectOutcome(error instanceof Error ? error : new Error(String(error)));
 			}
 		});
 	});
 }
-function signalChildGroup(child, signal) {
+/**
+* Send a direct-process signal, distinguishing an absent PID from failed delivery.
+* @param pid - owned direct-process identity whose exit notification can still be pending.
+* @param send - platform signal operation; true means the signal was submitted.
+* @returns whether the signal was submitted or the owned PID is already absent.
+*/
+function signalLinuxDirectProcess(pid, send) {
 	try {
-		process.kill(-child.pid, signal);
-	} catch {
-		try {
-			child.kill(signal);
-		} catch {}
+		if (send()) return true;
+	} catch {}
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return error.code === "ESRCH";
 	}
 }
+function signalChildGroup(child, signal) {
+	let groupSignalled = false;
+	try {
+		groupSignalled = process.kill(-child.pid, signal);
+	} catch {}
+	if (groupSignalled && signal === "SIGTERM") return true;
+	return signalLinuxDirectProcess(child.pid, () => process.kill(child.pid, signal));
+}
 /**
 * 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.
+* @returns invocation and ownership callbacks; requested termination preserves the observed signal even before bootstrap consumption.
 */
 function prepareLinuxTerminalScope(spec, targetEnv, internals = {}) {
 	const invocation = internals.runnerInvocation ?? spawnRunnerInvocation();
@@ -358,19 +437,15 @@ function prepareLinuxTerminalScope(spec, targetEnv, internals = {}) {
 		cwd: spec.cwd,
 		env: targetEnv
 	});
+	const startup = new LinuxScopeStartup(files, "terminal");
 	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;
-		},
+		bindOwner: (direct) => new SystemdScopeOwner(`${unitBase}.scope`, startup, direct, internals.systemctl ?? "systemctl", internals.spawnSync ?? spawnSync, internals.systemctlQuery ?? querySystemctl, internals.sleep ?? sleepWithAbort),
+		resolveOutcome: (outcome) => startup.resolveOutcome(outcome),
 		cleanup: () => {
 			cleanupLinuxLaunchFiles(files);
 		}
@@ -381,14 +456,16 @@ function prepareLinuxTerminalScope(spec, targetEnv, internals = {}) {
 * @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.
+* @returns streams, result, and scope owner; requested termination preserves the observed signal even before bootstrap consumption.
 */
 function launchLinuxScope(spec, targetEnv, internals = {}) {
 	const invocation = internals.runnerInvocation ?? spawnRunnerInvocation();
 	const files = createLinuxLaunchFiles({
 		cwd: spec.cwd,
-		env: targetEnv
+		env: targetEnv,
+		...spec.stdio.control === void 0 ? {} : { control: spec.stdio.control }
 	});
+	const startup = new LinuxScopeStartup(files, "subprocess");
 	const unitBase = unitStem("dsh-subprocess");
 	let child;
 	try {
@@ -402,17 +479,18 @@ function launchLinuxScope(spec, targetEnv, internals = {}) {
 		cleanupLinuxLaunchFiles(files);
 		throw error;
 	}
-	const owner = new SystemdScopeOwner(`${unitBase}.scope`, files, {
+	const direct = directOutcome(child, startup);
+	const owner = new SystemdScopeOwner(`${unitBase}.scope`, startup, {
 		running: () => child.pid !== void 0 && child.exitCode === null && child.signalCode === null,
-		signal: (signal) => {
-			signalChildGroup(child, signal);
-		}
+		signal: (signal) => signalChildGroup(child, signal),
+		settled: direct
 	}, 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),
+		control: controlPipe(child, spec.stdio.control),
+		direct,
 		owner
 	};
 }
@@ -513,10 +591,25 @@ function launchWindowsJob(spec, targetEnv, internals = {}) {
 	const rangeExit = Promise.withResolvers();
 	let directResultType;
 	let runnerSpawned = false;
+	let runnerExit;
+	let ipcDisconnected = false;
 	const failInfrastructure = (error) => {
 		direct.reject(error);
 		rangeExit.reject(error);
 	};
+	const settleRange = () => {
+		if (!runnerSpawned || runnerExit === void 0) return;
+		const { exitCode, signal } = runnerExit;
+		if (exitCode === 0 && signal === null) {
+			if (directResultType !== void 0) {
+				rangeExit.resolve();
+				return;
+			}
+			if (!ipcDisconnected) 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`));
+	};
 	const owner = new WindowsJobOwner(child, rangeExit.promise, () => directResultType, failInfrastructure);
 	child.on("message", (value) => {
 		if (directResultType !== void 0) {
@@ -538,6 +631,7 @@ function launchWindowsJob(spec, targetEnv, internals = {}) {
 			signal: null
 		});
 		else direct.reject(owner.mapStartFailure(deserializeRunnerError(result.error), result.error));
+		settleRange();
 	});
 	child.once("spawn", () => {
 		runnerSpawned = true;
@@ -546,7 +640,8 @@ function launchWindowsJob(spec, targetEnv, internals = {}) {
 			child.send({
 				type: "start",
 				cwd: spec.cwd,
-				env: targetEnv
+				env: targetEnv,
+				...spec.stdio.control === void 0 ? {} : { control: spec.stdio.control }
 			}, (error) => {
 				if (error === null) return;
 				failInfrastructure(error);
@@ -565,19 +660,22 @@ function launchWindowsJob(spec, targetEnv, internals = {}) {
 		}
 		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`));
+	child.once("exit", (exitCode, signal) => {
+		runnerExit = {
+			exitCode,
+			signal
+		};
+		settleRange();
+	});
+	child.once("disconnect", () => {
+		ipcDisconnected = true;
+		settleRange();
 	});
 	return {
 		stdin: spec.stdio.stdin === "ignore" ? null : targetStdin,
 		stdout: child.stdio[5],
 		stderr: child.stdio[6],
+		control: controlPipe(child, spec.stdio.control),
 		direct: direct.promise,
 		owner
 	};
@@ -634,6 +732,7 @@ var LocalTerminalHandle = class {
 	cleanup;
 	managedOwnerCleaned = false;
 	exited = false;
+	outputPaused = false;
 	trackedDescendants = [];
 	/** The spawned shell's start identity; scans stop adopting members once the root pid no longer carries it. */
 	rootIdentity;
@@ -653,8 +752,20 @@ var LocalTerminalHandle = class {
 		this.pid = terminal.pid;
 		this.rootIdentity = inspector.snapshot().tree(this.pid).find((member) => member.pid === this.pid);
 		this.done = this.outcome.promise;
+		const resume = () => {
+			if (!this.outputPaused) return;
+			this.outputPaused = false;
+			if (!this.exited) terminal.resume();
+		};
+		this.output.on("drain", resume);
+		this.output.once("close", () => {
+			this.output.off("drain", resume);
+		});
 		this.dataDisposable = terminal.onData((data) => {
-			this.output.write(Buffer.from(data, "utf8"));
+			if (!this.output.write(Buffer.from(data, "utf8")) && this.cleanup === void 0 && !this.outputPaused) {
+				this.outputPaused = true;
+				terminal.pause();
+			}
 		});
 		this.exitDisposable = terminal.onExit(({ exitCode, signal: exitSignal }) => {
 			if (this.exited) return;
@@ -679,6 +790,10 @@ var LocalTerminalHandle = class {
 		if (this.exited) throw new Error("terminal process has exited");
 		this.terminal.write(data);
 	}
+	async resize(cols, rows) {
+		if (this.exited) throw new Error("terminal process has exited");
+		this.terminal.resize(cols, rows);
+	}
 	async inspectForeground() {
 		this.descendants(this.inspector.snapshot());
 		const processGroupId = this.inspector.foregroundPgid(this.pid);
@@ -704,6 +819,10 @@ var LocalTerminalHandle = class {
 	}
 	terminate() {
 		if (this.cleanup !== void 0) return this.cleanup;
+		if (this.outputPaused) {
+			this.outputPaused = false;
+			this.terminal.resume();
+		}
 		const cleanup = this.closeOnce();
 		this.cleanup = cleanup;
 		cleanup.catch(() => {
@@ -916,6 +1035,8 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 	live = /* @__PURE__ */ new Set();
 	/** Live terminals retained through normal quiescence or host-exit finalization. */
 	terminals = /* @__PURE__ */ new Set();
+	/** Caller endpoints retained until close, independently of managed process lifetime. */
+	controlChannels = /* @__PURE__ */ new Set();
 	/** Test hook: process, spill, and platform operations forwarded to spawnSubprocess. */
 	internals = {};
 	/** Provider-lifetime latch suppressing repeated weaker-containment warnings. */
@@ -957,6 +1078,13 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 			this.terminals.delete(terminal);
 		}));
 		const outcomes = await Promise.allSettled(pending);
+		await Promise.all([...this.controlChannels].map((control) => new Promise((resolveClose) => {
+			control.once("close", () => {
+				resolveClose();
+			});
+			control.destroy();
+		})));
+		this.controlChannels.clear();
 		const failures = [];
 		for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
 		if (failures.length > 0) this.terminateForHostExit();
@@ -980,7 +1108,7 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 			} catch {}
 		}
 		signal?.throwIfAborted();
-		throw new Error(absolute ? `subprocess-local: command ${JSON.stringify(command)} is not an executable file` : `subprocess-local: command ${JSON.stringify(command)} was not found on PATH`);
+		throw new SubprocessExecutableNotFoundError(absolute ? `subprocess-local: command ${JSON.stringify(command)} is not an executable file` : `subprocess-local: command ${JSON.stringify(command)} was not found on PATH`);
 	}
 	executableCandidates(command, env) {
 		const path = environmentValue(env, "PATH") ?? "";
@@ -998,6 +1126,13 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 			handle = bindManagedProcess(spec, containmentMode === "linux-scope" ? launchLinuxScope(spec, env) : launchWindowsJob(spec, env), binding);
 		}
 		this.live.add(handle);
+		const control = handle.control;
+		if (control !== void 0) {
+			this.controlChannels.add(control);
+			control.once("close", () => {
+				this.controlChannels.delete(control);
+			});
+		}
 		const release = () => handle.waitForExit().then(() => {
 			this.live.delete(handle);
 		});
@@ -1025,23 +1160,36 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 		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()`);
 	}
+	/** @inheritdoc */
+	async terminalEnvironment(signal) {
+		signal?.throwIfAborted();
+		const platform = process.platform === "win32" ? "windows" : "posix";
+		const defaultShell = platform === "windows" ? process.env.ComSpec || void 0 : process.env.SHELL || userInfo().shell || void 0;
+		return {
+			platform,
+			...defaultShell === void 0 ? {} : { defaultShell }
+		};
+	}
 	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",
+			name: spec.terminalType,
 			rows: spec.rows,
 			cols: spec.cols,
 			cwd: spec.cwd,
-			env
+			env: {
+				...env,
+				TERM: spec.terminalType
+			}
 		};
 		const inspector = this.terminalInspector ?? createProcessInspector();
 		const scope = this.selectContainmentMode("terminal") === "linux-scope" ? prepareLinuxTerminalScope(spec, {
 			...env,
 			PWD: spec.cwd,
-			TERM: "dumb"
+			TERM: spec.terminalType
 		}) : void 0;
 		if (scope !== void 0) {
 			options.cwd = scope.cwd;
@@ -1055,17 +1203,16 @@ var LocalSubprocessRuntime = class extends SubprocessRuntime {
 			throw error;
 		}
 		let handle;
+		const directSettlement = Promise.withResolvers();
 		const owner = scope?.bindOwner({
 			running: () => handle?.running ?? true,
-			signal: (signal) => {
-				try {
-					terminal.kill(signal);
-				} catch {}
-			}
+			settled: directSettlement.promise,
+			signal: (signal) => signalLinuxDirectProcess(terminal.pid, () => process.kill(terminal.pid, signal))
 		});
 		handle = new LocalTerminalHandle(terminal, inspector, spec.graceMs, this.internals.platform ?? process.platform, owner, scope?.resolveOutcome);
 		this.terminals.add(handle);
 		const release = async () => {
+			directSettlement.resolve();
 			await handle.terminate();
 			this.terminals.delete(handle);
 		};