@deepseek-ai/dsh-subprocess-local 0.0.1-rc.2 → 0.0.1-rc.5

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/subprocess/subprocess-local/README.md
-README.md: 2817e02861db6caad89cad258d14a90c34afcbaf
-README.zh.md: 251b994a35e8bd7c84827957a548a1f352583ac6
+README.md: 645f05a0daf92d64c438f8aaae3b0e115f253a64
+README.zh.md: cd8c04071f00b298b2d242624c2ad1327758e16e

package/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-Local Service provider for the [`@deepseek-ai/dsh-subprocess`](../subprocess/README.md) seam. `LocalSubprocessService` resolves local executables, spawns ordinary detached process trees with explicit stdio, and implements terminal processes through `node-pty` plus platform process inspection. It has no config: every disposition, limit, terminal dimension, grace, and directory arrives from the calling capability seams ([`dsh-bash-local`](../../bash/bash-local/README.md), [`dsh-lsp-local`](../../lsp/lsp-local/README.md), and [`dsh-pty-local`](../../pty/pty-local/README.md)).
+Local Service provider for the [`@deepseek-ai/dsh-subprocess`](../subprocess/README.md) seam. `LocalSubprocessRuntime` resolves local executables, spawns ordinary detached process trees with explicit stdio, and implements terminal processes through `node-pty` plus platform process inspection. It has no config: every disposition, limit, terminal dimension, grace, and directory arrives from the calling capability seams ([`dsh-bash-local`](../../shell/bash-local/README.md), [`dsh-lsp-stdio`](../../lsp/lsp-stdio/README.md), and [`dsh-terminal-bash`](../../terminal/terminal-bash/README.md)).
 
 ## Behavior
 
@@ -12,7 +12,8 @@ Local Service provider for the [`@deepseek-ai/dsh-subprocess`](../subprocess/REA
 - **Offset-based reads** — collect-mode readers return deltas in whole-stream byte coordinates; the service never holds a cursor, so consumer-owned cursors (the bash background read path) and full-stream re-reads coexist, before and after settlement.
 - **Executable lookup** — `resolveExecutable` checks absolute files or searches the scrubbed effective PATH with platform-aware executable extensions; relative paths containing separators are rejected at the seam, and relative PATH entries resolve from the host process cwd.
 - **Terminal-process ownership** — `spawnTerminal` allocates `node-pty`, bridges UTF-8 terminal text, inspects and signals the current foreground process group, and exposes one awaited termination operation that sweeps descendants before and after terminating the top-level shell. Each foreground inspection retains exact identities from the rooted tree; Linux also enumerates the POSIX session after its leader exits. A previously observed macOS descendant and any same-session Linux member therefore remain fenced after reparenting, while pid/start identity prevents cleanup from following PID reuse. The higher PTY backend owns prompt readiness, buffers, and model-facing operations.
-- **Terminate-and-join disposal** — the service retains live handles only so its own disposal can escalate every running tree and await its exit; settled and spawn-failed handles leave the live set on settlement.
+- **Terminate-and-join disposal** — the service retains live handles so its own disposal can escalate every running tree and await its exit; quiescent and spawn-failed handles leave the live set after whole-tree or terminal-session cleanup finishes.
+- **Synchronous host-exit finalization** — while the service effect is active, a Node `exit` listener force-terminates every ordinary tree and observable terminal session still in the same live sets. The local-only operations send POSIX SIGKILL to the managed group, run Windows `taskkill /T /F`, and synchronously signal captured/current terminal identities around the PTY root kill; they create no promise or timer, preserve the host's exit code and diagnostic, contain each target's failure, and do not claim quiescence. Normal disposal keeps the awaited graceful path above. See the [host-exit cleanup decision](../../../.agents/notes/implemented/bug-fix/2026-08-11-synchronous-subprocess-exit-cleanup.md).
 
 ## Model Experience
 
@@ -27,6 +28,7 @@ No direct invalidation; the named consumers own any request-prefix changes.
 - **Windows tree support is best-effort** — termination routes through `taskkill /PID <pid> /T /F` with all outcomes contained (absent tree, races, missing binary), and liveness falls back to the direct-child boundary.
 - **Terminal process inspection is Linux/macOS only** — the terminal primitive fails when its inspector has no supported platform implementation; Linux exact probes cover x64 and arm64, while macOS uses `ps` snapshots.
 - **A daemonized terminal descendant can still escape the observable boundary** — on macOS, a child that reparents before any foreground-inspection snapshot is no longer discoverable from the `node-pty` root; on Linux, a child that calls `setsid` leaves both the tree and owned terminal session. The local provider does not add a continuous process-table monitor.
+- **In-process cleanup requires a JavaScript-observable exit** — direct `process.exit()`, default uncaught exceptions, and default unhandled rejections emit Node's synchronous `exit` event. The default OS disposition for an unhandled `SIGTERM`, `SIGINT`, or `SIGHUP` bypasses that event; an application covers those signals only by installing a handler that performs normal disposal or calls `process.exit()`. `SIGKILL`, fatal OOM, `process.abort()`, native crashes, power loss, and any failure that cannot run JavaScript require an external supervisor, container init, or equivalent OS owner.
 - **The credential scrub is a name heuristic** — `*KEY*`/`*PASSWORD*`/`*SECRET*`/`*TOKEN*` only; differently-named secrets (e.g. `*PASSPHRASE*`) pass through, and a whitelist for over-scrubbed vars is noted future work.
 - **Completed spill files are not deleted** — bounded full-output recovery files (and the private per-process spill dir) accumulate under the OS tmpdir until something external cleans them; oversize incomplete spills are discarded and deletion is attempted immediately, but a cleanup failure can leave a bounded file behind.
 

package/README.zh.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-[`@deepseek-ai/dsh-subprocess`](../subprocess/README.md) seam 的本地 Service provider。`LocalSubprocessService` 解析本地可执行文件，以显式 stdio spawn 普通 detached 进程树，并通过 `node-pty` 加平台进程检查实现终端进程。该实现没有任何配置：每项处置方式、限制、终端尺寸、宽限期与目录都来自调用方能力 seam（[`dsh-bash-local`](../../bash/bash-local/README.md)、[`dsh-lsp-local`](../../lsp/lsp-local/README.md) 和 [`dsh-pty-local`](../../pty/pty-local/README.md)）。
+[`@deepseek-ai/dsh-subprocess`](../subprocess/README.md) seam 的本地 Service provider。`LocalSubprocessRuntime` 解析本地可执行文件，以显式 stdio spawn 普通 detached 进程树，并通过 `node-pty` 加平台进程检查实现终端进程。该实现没有任何配置：每项处置方式、限制、终端尺寸、宽限期与目录都来自调用方能力 seam（[`dsh-bash-local`](../../shell/bash-local/README.md)、[`dsh-lsp-stdio`](../../lsp/lsp-stdio/README.md) 和 [`dsh-terminal-bash`](../../terminal/terminal-bash/README.md)）。
 
 ## 行为
 
@@ -10,9 +10,10 @@
 - **按流划分的处置方式**：`'pipe'` 把原始流原样交给调用方（协议分帧仍归消费方所有）；`'inherit'` 直通父进程的描述符；收集模式（collect）在输出超过上限后于内存中保留尾部（错误与结果通常聚集在末尾，沿用 pi/OpenCode 的理由），并在配置了 spill 上限时把完整流追加到一个私有临时文件；省略 `spill` 则只保留用于诊断的尾部。某条流大于 spill 上限时，会丢弃已不完整的 spill，仅返回带截断标记的尾部；spill 文件描述符在结算时封存，最终关闭失败时则不公布路径，以免声称存在不完整的文件。spill 文件权限为 `0600`、名称随机，位于按需创建、权限为 `0700` 的每进程目录之下。
 - **凭据清除 + 显式合并**：以 `process.env` 为基础，移除形似凭据的变量（`*KEY*`／`*PASSWORD*`／`*SECRET*`／`*TOKEN*`）和所有环境中已有的 `DSH_*` 名称；spec 的显式 `env` 在该清除之后合并且不做命名空间校验，因此有意提供的凭据或当前 `DSH_*` 事实会胜出，而陈旧的嵌套 harness 身份无法从环境中隐式漏入。提供的 stdin 会被写入后关闭；否则 fd 0 指向 `/dev/null`。参见 [stdin/env Agent Note](../../../.agents/notes/implemented/architecture/2026-06-30-bash-stdin-env-trusted-plugin-api.md)与[受管环境 Agent Note](../../../.agents/notes/implemented/feature/2026-07-10-agent-session-identity-and-log-location.md)。
 - **基于偏移量的读取**：收集模式的读取器按完整流的字节坐标返回增量；服务自身从不持有游标，因此消费方自有的游标（bash 的后台读取路径）与完整流重读可以共存，结算前后皆然。
-- **可执行文件查找**：`resolveExecutable` 检查绝对文件，或根据平台可执行文件扩展名在清理后的有效 PATH 中搜索；含分隔符的相对路径在该能力入口被拒绝，相对 PATH 条目从宿主进程 cwd 解析。
+- **可执行文件查找**：`resolveExecutable` 检查绝对文件，或根据平台可执行文件扩展名在清理后的有效 PATH 中搜索；含分隔符的相对路径在该 seam 处被拒绝，相对 PATH 条目从宿主进程 cwd 解析。
 - **终端进程所有权**：`spawnTerminal` 分配 `node-pty`，桥接 UTF-8 终端文本，检查当前前台进程组并向其发送信号，还会公开一项须等待的终止操作，在终止顶层 shell 前后清理后代进程。每次前台检查都会保留根进程树中的精确身份；Linux 还会在 POSIX 会话 leader 退出后枚举该会话。因此，之前观察到的 macOS 后代以及同会话 Linux 成员在重新设定父进程后仍受围栏保护，pid/start 身份则防止清理跟随 PID 复用。上层 PTY 后端负责提示符就绪、缓冲区与面向模型的操作。
-- **先终止再等待退出的 dispose（资源释放）**：服务保留存活句柄，只为让自身的 dispose 能对每个仍在运行的进程树执行升级并等待其退出；已结算与 spawn 失败的句柄在结算时即离开存活集合。
+- **先终止再等待退出的 dispose（资源释放）**：服务保留存活句柄，使自身的 dispose 能对每个仍在运行的进程树执行升级并等待其退出；完全停稳与 spawn 失败的句柄会在整棵进程树或 terminal session 清理完成后离开存活集合。
+- **同步宿主退出最终清理**：服务 effect 仍有效时，Node `exit` listener 会强制终止同一组存活集合中仍存在的每棵普通进程树和可观察 terminal session。这些仅供本地实现使用的操作会向受管 POSIX 进程组发送 SIGKILL、在 Windows 运行 `taskkill /T /F`，并在终止 PTY root 前后同步向已捕获及当前可观察的 terminal 身份发送信号；它们不会创建 Promise 或 timer，不改变宿主退出码与诊断，会分别包含每个目标的失败，也不会声称已经完全停稳。正常 dispose 仍使用上面的须等待温和路径。参见[宿主退出清理决策](../../../.agents/notes/implemented/bug-fix/2026-08-11-synchronous-subprocess-exit-cleanup.md)。
 
 ## 模型体验
 
@@ -27,6 +28,7 @@
 - **Windows 进程树支持仅为尽力而为**：终止经由 `taskkill /PID <pid> /T /F` 完成，所有结果都被就地吸收，不向外抛出（进程树已不存在、竞态、二进制缺失），存活探测则回退到直接子进程边界。
 - **终端进程检查仅支持 Linux／macOS**：检查器没有受支持的平台实现时，终端原语会失败；Linux 精确探针覆盖 x64 与 arm64，macOS 则使用 `ps` 快照。
 - **守护化的终端后代仍可能逃出可观察边界**：在 macOS 上，子进程如果在任何前台检查快照之前重新设定父进程，将无法再从 `node-pty` 根进程发现；在 Linux 上，调用 `setsid` 的子进程会同时离开进程树与自有终端会话。本地提供方不会新增持续进程表监视器。
+- **进程内清理要求退出阶段仍能执行 JavaScript**：直接 `process.exit()`、默认未捕获异常和默认未处理 rejection 会发出 Node 同步 `exit` 事件。未安装 handler 时，`SIGTERM`、`SIGINT` 或 `SIGHUP` 的默认 OS 处置不会发出该事件；应用只有安装执行正常 dispose 或调用 `process.exit()` 的 handler 才能覆盖这些信号。`SIGKILL`、fatal OOM、`process.abort()`、native crash、断电，以及任何无法运行 JavaScript 的故障，都需要外部 supervisor、容器 init 或等价的 OS 所有者负责。
 - **凭据清除依赖名称启发式规则**：只匹配 `*KEY*`／`*PASSWORD*`／`*SECRET*`／`*TOKEN*`；名称不同的 secret（例如 `*PASSPHRASE*`）会继续传递，对误删变量引入白名单属于已记录的后续工作。
 - **不会删除已完成的 spill 文件**：有界的完整输出恢复文件（以及每个进程的私有 spill 目录）会在 OS tmpdir 下累积，直到外部机制进行清理；超大的不完整 spill 会被丢弃并立即尝试删除，但清理失败可能留下一个有界文件。
 

package/lib/index.js

@@ -2,7 +2,7 @@ import { closeSync, constants, mkdtempSync, openSync, readFileSync, readSync, re
 import { access, stat } from "node:fs/promises";
 import { delimiter, extname, isAbsolute, join, resolve } from "node:path";
 import * as nodePty from "node-pty";
-import { SubprocessService, scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
+import { SubprocessRuntime, scrubbedParentEnv } from "@deepseek-ai/dsh-subprocess";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { constants as constants$1, tmpdir } from "node:os";
@@ -621,6 +621,9 @@ function spawnSubprocess(spec, internals = {}) {
 			kill("SIGKILL");
 		}, spec.graceMs);
 	};
+	const terminateForHostExit = () => {
+		kill("SIGKILL");
+	};
 	const onAbort = () => {
 		terminate();
 	};
@@ -694,6 +697,7 @@ function spawnSubprocess(spec, internals = {}) {
 		},
 		done,
 		terminate,
+		terminateForHostExit,
 		waitForExit
 	};
 }
@@ -785,6 +789,27 @@ var LocalTerminalHandle = class {
 		});
 		return cleanup;
 	}
+	/**
+	* Force-terminate the observable session synchronously during Node's exit
+	* event. This does not claim quiescence and does not replace terminate().
+	*/
+	terminateForHostExit() {
+		this.forceStopDescendants();
+		this.forceStopShell();
+		this.forceStopDescendants();
+	}
+	forceStopShell() {
+		if (this.exited) return;
+		if (this.rootIdentity !== void 0) {
+			try {
+				this.inspector.signalProcess(this.rootIdentity, "SIGKILL");
+			} catch (_rootExitedDuringHostExit) {}
+			return;
+		}
+		try {
+			this.terminal.kill("SIGKILL");
+		} catch (_unidentifiedShellExitedDuringHostExit) {}
+	}
 	survivors(members) {
 		return members.filter((member) => this.inspector.isAlive(member));
 	}
@@ -809,6 +834,13 @@ var LocalTerminalHandle = class {
 			this.inspector.signalProcess(member, signal);
 		} catch (_alreadyExitedDuringSignal) {}
 	}
+	forceStopDescendants() {
+		let members = this.trackedDescendants;
+		try {
+			members = this.descendants();
+		} catch (_processTableUnavailableDuringHostExit) {}
+		this.signalMembers(members, "SIGKILL");
+	}
 	unionMembers(...groups) {
 		const members = [];
 		const seen = /* @__PURE__ */ new Set();
@@ -858,8 +890,9 @@ var LocalTerminalHandle = class {
 //#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; disposal
-* terminates and joins live trees. It has no config: every disposition and
+* 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, …).
 * @module @deepseek-ai/dsh-subprocess-local
@@ -868,12 +901,13 @@ var LocalTerminalHandle = class {
 * Local subprocess service: detached process trees, 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.
+* SIGTERM→grace→SIGKILL escalation, plus synchronous final termination during
+* JavaScript-observable host exit.
 */
-var LocalSubprocessService = class extends SubprocessService {
-	/** Live handles retained only so disposal can terminate and join them. */
+var LocalSubprocessRuntime = class extends SubprocessRuntime {
+	/** Live handles retained for normal disposal and synchronous host-exit finalization. */
 	live = /* @__PURE__ */ new Set();
-	/** Live terminal sessions retained through whole-session quiescence. */
+	/** Live terminals retained through normal quiescence or host-exit finalization. */
 	terminals = /* @__PURE__ */ new Set();
 	/** Test hook: spill and platform knobs forwarded to spawnSubprocess. */
 	internals = {};
@@ -881,20 +915,42 @@ var LocalSubprocessService = class extends SubprocessService {
 	terminalInspector;
 	constructor(ctx) {
 		super(ctx);
-		ctx.effect(() => async () => {
-			const pending = [];
-			for (const handle of this.live) {
-				handle.terminate();
-				pending.push(handle.done.catch(() => {}).then(() => handle.waitForExit()));
-			}
-			for (const terminal of this.terminals) pending.push(terminal.terminate());
-			this.live.clear();
-			this.terminals.clear();
-			const failures = (await Promise.allSettled(pending)).flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-			if (failures.length === 1) throw failures[0];
-			if (failures.length > 1) throw new AggregateError(failures, "local subprocess teardown failed");
+		ctx.effect(() => {
+			const onHostExit = () => {
+				this.terminateForHostExit();
+			};
+			process.prependListener("exit", onHostExit);
+			return async () => {
+				try {
+					await this.disposeManagedProcesses();
+				} finally {
+					process.off("exit", onHostExit);
+				}
+			};
 		}, "local subprocess teardown");
 	}
+	terminateForHostExit() {
+		for (const handle of this.live) try {
+			handle.terminateForHostExit();
+		} catch (_ordinaryTreeTerminationFailed) {}
+		for (const terminal of this.terminals) try {
+			terminal.terminateForHostExit();
+		} catch (_terminalTerminationFailed) {}
+	}
+	async disposeManagedProcesses() {
+		const pending = [];
+		for (const handle of this.live) {
+			handle.terminate();
+			pending.push(handle.done.catch(() => {}).then(() => handle.waitForExit()));
+		}
+		for (const terminal of this.terminals) pending.push(terminal.terminate());
+		const failures = (await Promise.allSettled(pending)).flatMap((outcome) => outcome.status === "rejected" ? [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");
+	}
 	async resolveExecutable(command, env, signal) {
 		if (command.length === 0) throw new Error("subprocess-local: executable must be non-empty");
 		signal?.throwIfAborted();
@@ -958,4 +1014,4 @@ function environmentValue(env, name) {
 	return Object.entries(env).find(([key]) => key.toUpperCase() === normalized)?.[1];
 }
 //#endregion
-export { LocalSubprocessService, LocalSubprocessService as default };
+export { LocalSubprocessRuntime, LocalSubprocessRuntime as default };

package/lib/types/index.d.ts

@@ -1,13 +1,14 @@
 /**
  * Local Service provider for the subprocess capability seam. Each spawn is a detached
- * process tree with the spec's per-stream stdio dispositions; disposal
- * terminates and joins live trees. It has no config: every disposition and
+ * 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, …).
  * @module @deepseek-ai/dsh-subprocess-local
  */
 import { Context } from '@deepseek-ai/cordis';
-import { SubprocessService } from '@deepseek-ai/dsh-subprocess';
+import { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess';
 import type { SubprocessHandle, SubprocessSpawnSpec, SubprocessTerminalHandle, SubprocessTerminalSpawnSpec } from '@deepseek-ai/dsh-subprocess';
 import type { SpawnInternals } from './spawn.ts';
 import type { ProcessInspector } from './process-inspector.ts';
@@ -15,22 +16,25 @@ import type { ProcessInspector } from './process-inspector.ts';
  * Local subprocess service: detached process trees, 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.
+ * SIGTERM→grace→SIGKILL escalation, plus synchronous final termination during
+ * JavaScript-observable host exit.
  */
-export declare class LocalSubprocessService extends SubprocessService {
-    /** Live handles retained only so disposal can terminate and join them. */
+export declare class LocalSubprocessRuntime extends SubprocessRuntime {
+    /** Live handles retained for normal disposal and synchronous host-exit finalization. */
     private live;
-    /** Live terminal sessions retained through whole-session quiescence. */
+    /** Live terminals retained through normal quiescence or host-exit finalization. */
     private terminals;
     /** Test hook: spill and platform knobs forwarded to spawnSubprocess. */
     internals: SpawnInternals;
     /** Test hook for platform process inspection; production resolves lazily on terminal spawn. */
     terminalInspector: ProcessInspector | undefined;
     constructor(ctx: Context);
+    private terminateForHostExit;
+    private disposeManagedProcesses;
     resolveExecutable(command: string, env?: Readonly<Record<string, string>>, signal?: AbortSignal): Promise<string>;
     private executableCandidates;
     spawn(spec: SubprocessSpawnSpec): SubprocessHandle;
     spawnTerminal(spec: SubprocessTerminalSpawnSpec): Promise<SubprocessTerminalHandle>;
 }
-export default LocalSubprocessService;
+export default LocalSubprocessRuntime;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/spawn.d.ts

@@ -27,6 +27,15 @@ export interface SpawnInternals {
     /** Linux process-group member probe (defaults to `/proc` inspection). */
     linuxProcessGroupHasLiveMembers?: (processGroupId: number) => boolean | undefined;
 }
+/**
+ * Local-only synchronous final termination used by the owning service during
+ * host exit and as the last fallback after failed normal disposal. It is
+ * intentionally absent from the public subprocess seam.
+ */
+export interface LocalSubprocessHandle extends SubprocessHandle {
+    /** Force-terminate the current tree synchronously without starting timers or waits. */
+    terminateForHostExit(): void;
+}
 /**
  * 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
@@ -117,5 +126,5 @@ export declare function taskkillProcessTree(pid: number): void;
  * @returns live subprocess handle.
  * @throws when `graceMs` cannot be represented by one Node timer.
  */
-export declare function spawnSubprocess(spec: SubprocessSpawnSpec, internals?: SpawnInternals): SubprocessHandle;
+export declare function spawnSubprocess(spec: SubprocessSpawnSpec, internals?: SpawnInternals): LocalSubprocessHandle;
 //# sourceMappingURL=spawn.d.ts.map

package/lib/types/terminal.d.ts

@@ -36,10 +36,17 @@ export declare class LocalTerminalHandle implements SubprocessTerminalHandle {
     inspectForeground(): Promise<SubprocessTerminalForeground | undefined>;
     signalForeground(signal: SubprocessTerminalSignal): Promise<number>;
     terminate(): Promise<void>;
+    /**
+     * Force-terminate the observable session synchronously during Node's exit
+     * event. This does not claim quiescence and does not replace terminate().
+     */
+    terminateForHostExit(): void;
+    private forceStopShell;
     private survivors;
     private descendants;
     private waitForMembers;
     private signalMembers;
+    private forceStopDescendants;
     private unionMembers;
     private stopDescendants;
     private stopShell;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-subprocess-local",
   "description": "Local-subprocess implementation of the DeepSeek Harness subprocess seam",
-  "version": "0.0.1-rc.2",
+  "version": "0.0.1-rc.5",
   "publishConfig": {
     "access": "restricted"
   },
@@ -33,19 +33,20 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.5",
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.5"
   },
   "dependencies": {
     "node-pty": "^1.1.0"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-loader-smoke": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.5",
+    "@deepseek-ai/cordis": "^4.0.1-rc.4"
   },
   "scripts": {
     "postinstall": "node scripts/ensure-spawn-helper.mjs"