@code-yeongyu/senpi-agent-core 2026.10.10-10 → 2026.10.10-12

package/dist/harness/env/nodejs.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result, type ShellExecOptions, type ShellExecResult, type TextLineReader } from "../types.ts";
+import { type WindowsProcessRow } from "./windows-process-tree.ts";
 /**
  * Ordered `taskkill` launchers to try, most reliable first.
  *
@@ -11,7 +12,10 @@ import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Resul
  */
 export declare function windowsTaskkillCandidates(env?: NodeJS.ProcessEnv): string[];
 /**
- * Kill a process and all its children on Windows via `taskkill /T`.
+ * Kill a process and its descendants on Windows: one process listing (bounded by `TASKKILL_TIMEOUT_MS`)
+ * decides the tree, a process counting as a child only when it started at or after the parent it names,
+ * and `taskkill /F` ends each pid by name. `/T` would also adopt an unrelated older process through a
+ * recycled parent pid (senpi#2999); it is used only when no listing can be read.
  *
  * Synchronous on purpose. A caller that tears down and exits in the same tick would never
  * observe an asynchronous killer's `error` event, leaving the target alive. `spawnSync`
@@ -24,7 +28,7 @@ export declare function windowsTaskkillCandidates(env?: NodeJS.ProcessEnv): stri
  * touch descendants; nothing in-process can walk a Windows process tree without an
  * external tool, so this still beats leaving the whole tree running.
  */
-export declare function killWindowsProcessTree(pid: number, taskkillPaths?: string[]): void;
+export declare function killWindowsProcessTree(pid: number, taskkillPaths?: string[], listProcesses?: () => readonly WindowsProcessRow[] | undefined): void;
 export declare class NodeExecutionEnv implements ExecutionEnv {
     cwd: string;
     private shellPath?;

package/dist/harness/env/nodejs.js

@@ -7,6 +7,7 @@ import { basename, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ExecutionError, err, FileError, ok, toError, } from "../types.js";
 import { OutputCapture } from "../utils/output-capture.js";
+import { listWindowsProcessRowsSync, windowsTreeKillArgs } from "./windows-process-tree.js";
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
 const EXIT_STDIO_GRACE_MS = 100;
@@ -237,9 +238,14 @@ function killProcessDirectly(pid) {
 }
 /** Upper bound on how long a teardown may block waiting for `taskkill` to finish. */
 const TASKKILL_TIMEOUT_MS = 5_000;
-function taskkillHandledTree(pid, taskkillPath) {
+function listWindowsProcesses() {
+    return listWindowsProcessRowsSync(TASKKILL_TIMEOUT_MS);
+}
+function taskkillHandledTree(taskkillPath, killArgs) {
+    if (killArgs.length === 0)
+        return true;
     try {
-        const result = spawnSync(taskkillPath, ["/F", "/T", "/PID", String(pid)], {
+        const result = spawnSync(taskkillPath, [...killArgs], {
             stdio: "ignore",
             windowsHide: true,
             timeout: TASKKILL_TIMEOUT_MS,
@@ -253,7 +259,10 @@ function taskkillHandledTree(pid, taskkillPath) {
     }
 }
 /**
- * Kill a process and all its children on Windows via `taskkill /T`.
+ * Kill a process and its descendants on Windows: one process listing (bounded by `TASKKILL_TIMEOUT_MS`)
+ * decides the tree, a process counting as a child only when it started at or after the parent it names,
+ * and `taskkill /F` ends each pid by name. `/T` would also adopt an unrelated older process through a
+ * recycled parent pid (senpi#2999); it is used only when no listing can be read.
  *
  * Synchronous on purpose. A caller that tears down and exits in the same tick would never
  * observe an asynchronous killer's `error` event, leaving the target alive. `spawnSync`
@@ -266,9 +275,10 @@ function taskkillHandledTree(pid, taskkillPath) {
  * touch descendants; nothing in-process can walk a Windows process tree without an
  * external tool, so this still beats leaving the whole tree running.
  */
-export function killWindowsProcessTree(pid, taskkillPaths = windowsTaskkillCandidates()) {
+export function killWindowsProcessTree(pid, taskkillPaths = windowsTaskkillCandidates(), listProcesses = listWindowsProcesses) {
+    const killArgs = windowsTreeKillArgs(pid, listProcesses());
     for (const taskkillPath of taskkillPaths) {
-        if (taskkillHandledTree(pid, taskkillPath))
+        if (taskkillHandledTree(taskkillPath, killArgs))
             return;
     }
     killProcessDirectly(pid);
@@ -959,8 +969,16 @@ export class NodeExecutionEnv {
         }
     }
     async cleanup(_context) {
-        for (const pid of this.activeChildPids)
-            killProcessTree(pid);
+        if (process.platform === "win32" && this.activeChildPids.size > 0) {
+            // One listing for the whole batch: each tree kill would otherwise list every process again.
+            const rows = listWindowsProcesses();
+            for (const pid of this.activeChildPids)
+                killWindowsProcessTree(pid, undefined, () => rows);
+        }
+        else {
+            for (const pid of this.activeChildPids)
+                killProcessTree(pid);
+        }
         this.activeChildPids.clear();
     }
 }

package/dist/harness/env/windows-process-tree.d.ts

@@ -0,0 +1,33 @@
+export interface WindowsProcessRow {
+    readonly pid: number;
+    readonly parentPid: number;
+    readonly createdAt: bigint;
+    readonly name: string;
+}
+/** One `pid parentPid createdFileTime name` line per process; the listing's own PowerShell is left out. */
+export declare const WINDOWS_PROCESS_TREE_ROWS = "Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID } | ForEach-Object {\n$created = if ($_.CreationDate) { $_.CreationDate.ToFileTimeUtc() } else { 0 }\n\"{0} {1} {2} {3}\" -f $_.ProcessId, $_.ParentProcessId, $created, $_.Name }";
+export declare function parseWindowsProcessTreeRows(stdout: string): WindowsProcessRow[];
+export interface WindowsTreeKillPlan {
+    /** Pids to end with one `taskkill /F /PID a /PID b ...` (never /T). */
+    readonly kill: readonly number[];
+    /** Processes the walk adopted that must never be killed; any entry here means only the root is killed. */
+    readonly refused: readonly {
+        readonly pid: number;
+        readonly name: string;
+    }[];
+}
+/**
+ * The root and every process that genuinely descends from it. A protected OS image or an ancestor of
+ * `selfPid` in that set means the walk went wrong, so only the root itself is killed (and nothing when
+ * the root is one of them).
+ */
+export declare function windowsTreeKillPlan(rows: readonly WindowsProcessRow[], rootPid: number, selfPid: number): WindowsTreeKillPlan;
+/** Bounded synchronous CIM listing; undefined when it cannot run or does not finish in time. */
+export declare function listWindowsProcessRowsSync(timeoutMs: number): WindowsProcessRow[] | undefined;
+/**
+ * `taskkill` arguments for one tree kill. With a process listing, the checked tree is named pid by pid
+ * (never `/T`). Without one, `/T` is kept: leaving every descendant running is the worse failure, and the
+ * recycled-pid hazard needs a pid wraparound that a missing listing does not make more likely.
+ */
+export declare function windowsTreeKillArgs(rootPid: number, rows: readonly WindowsProcessRow[] | undefined, selfPid?: number): string[];
+//# sourceMappingURL=windows-process-tree.d.ts.map

package/dist/harness/env/windows-process-tree.js

@@ -0,0 +1,95 @@
+import { spawnSync } from "node:child_process";
+/** One `pid parentPid createdFileTime name` line per process; the listing's own PowerShell is left out. */
+export const WINDOWS_PROCESS_TREE_ROWS = `Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID } | ForEach-Object {
+$created = if ($_.CreationDate) { $_.CreationDate.ToFileTimeUtc() } else { 0 }
+"{0} {1} {2} {3}" -f $_.ProcessId, $_.ParentProcessId, $created, $_.Name }`;
+export function parseWindowsProcessTreeRows(stdout) {
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/u)) {
+        const [pidText, parentText, createdText, ...nameParts] = line.trim().split(/\s+/u);
+        const pid = Number(pidText);
+        const parentPid = Number(parentText);
+        if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(parentPid) || !/^\d+$/u.test(createdText ?? ""))
+            continue;
+        rows.push({ pid, parentPid, createdAt: BigInt(createdText ?? "0"), name: nameParts.join(" ") });
+    }
+    return rows;
+}
+const PROTECTED_IMAGES = new Set([
+    "system",
+    "smss.exe",
+    "csrss.exe",
+    "wininit.exe",
+    "winlogon.exe",
+    "services.exe",
+    "lsass.exe",
+    "lsaiso.exe",
+    "svchost.exe",
+]);
+/**
+ * The root and every process that genuinely descends from it. A protected OS image or an ancestor of
+ * `selfPid` in that set means the walk went wrong, so only the root itself is killed (and nothing when
+ * the root is one of them).
+ */
+export function windowsTreeKillPlan(rows, rootPid, selfPid) {
+    const byPid = new Map(rows.map((row) => [row.pid, row]));
+    const root = byPid.get(rootPid);
+    if (root === undefined)
+        return { kill: [], refused: [] };
+    const tree = new Set([rootPid]);
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const row of rows) {
+            if (tree.has(row.pid) || !tree.has(row.parentPid))
+                continue;
+            const parent = byPid.get(row.parentPid);
+            if (parent === undefined || row.createdAt < parent.createdAt)
+                continue;
+            tree.add(row.pid);
+            grew = true;
+        }
+    }
+    const ancestors = new Set([selfPid]);
+    for (let current = byPid.get(selfPid); current !== undefined;) {
+        const parent = byPid.get(current.parentPid);
+        if (parent === undefined || ancestors.has(parent.pid) || parent.createdAt > current.createdAt)
+            break;
+        ancestors.add(parent.pid);
+        current = parent;
+    }
+    const refused = [...tree]
+        .map((pid) => ({ pid, name: byPid.get(pid)?.name ?? "" }))
+        .filter((entry) => PROTECTED_IMAGES.has(entry.name.toLowerCase()) || ancestors.has(entry.pid));
+    if (refused.length === 0)
+        return { kill: [...tree], refused };
+    const rootRefused = refused.some((entry) => entry.pid === rootPid);
+    return { kill: rootRefused ? [] : [rootPid], refused };
+}
+/** Bounded synchronous CIM listing; undefined when it cannot run or does not finish in time. */
+export function listWindowsProcessRowsSync(timeoutMs) {
+    const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_PROCESS_TREE_ROWS], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    if (result.error !== undefined || result.status !== 0 || typeof result.stdout !== "string")
+        return undefined;
+    const rows = parseWindowsProcessTreeRows(result.stdout);
+    return rows.length > 0 ? rows : undefined;
+}
+/**
+ * `taskkill` arguments for one tree kill. With a process listing, the checked tree is named pid by pid
+ * (never `/T`). Without one, `/T` is kept: leaving every descendant running is the worse failure, and the
+ * recycled-pid hazard needs a pid wraparound that a missing listing does not make more likely.
+ */
+export function windowsTreeKillArgs(rootPid, rows, selfPid = process.pid) {
+    if (rows === undefined)
+        return ["/F", "/T", "/PID", String(rootPid)];
+    const pids = windowsTreeKillPlan(rows, rootPid, selfPid).kill;
+    if (pids.length === 0)
+        return [];
+    return ["/F", ...pids.flatMap((pid) => ["/PID", String(pid)])];
+}
+//# sourceMappingURL=windows-process-tree.js.map

package/dist/node.d.ts

@@ -1,3 +1,4 @@
 export { NodeExecutionEnv } from "./harness/env/nodejs.ts";
+export { listWindowsProcessRowsSync, parseWindowsProcessTreeRows, type WindowsProcessRow, type WindowsTreeKillPlan, windowsTreeKillArgs, windowsTreeKillPlan, } from "./harness/env/windows-process-tree.ts";
 export * from "./index.ts";
 //# sourceMappingURL=node.d.ts.map

package/dist/node.js

@@ -1,3 +1,4 @@
 export { NodeExecutionEnv } from "./harness/env/nodejs.js";
+export { listWindowsProcessRowsSync, parseWindowsProcessTreeRows, windowsTreeKillArgs, windowsTreeKillPlan, } from "./harness/env/windows-process-tree.js";
 export * from "./index.js";
 //# sourceMappingURL=node.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.10-10",
+	"version": "2026.10.10-12",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -62,8 +62,8 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.10-10",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.10-10",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.10-12",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.10-12",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",