omegon 0.6.8 → 0.6.10

package/extensions/cleave/dispatcher.ts

@@ -27,6 +27,7 @@ import { executeWithReview, type ReviewConfig, type ReviewExecutor, DEFAULT_REVI
 import { saveState } from "./workspace.ts";
 import { resolveTier, getDefaultPolicy, getViableModels, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
 import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
+import { registerCleaveProc, deregisterCleaveProc, killCleaveProc } from "./subprocess-tracker.ts";
 
 // ─── Large-run threshold ────────────────────────────────────────────────────
 
@@ -385,6 +386,7 @@ async function spawnChild(
 		const proc = spawn(omegon.command, args, {
 			cwd,
 			stdio: ["pipe", "pipe", "pipe"],
+			detached: true,
 			env: {
 				...process.env,
 				// Prevent nested detection issues
@@ -393,6 +395,7 @@ async function spawnChild(
 				I_AM: "alpharius",
 			},
 		});
+		registerCleaveProc(proc);
 
 		// Write prompt to stdin
 		if (proc.stdin) {
@@ -417,24 +420,43 @@ async function spawnChild(
 		});
 		proc.stderr?.on("data", (data) => { stderr += data.toString(); });
 
+		// SIGKILL escalation helper — sends SIGKILL by process group with fallback
+		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
+		const scheduleEscalation = () => {
+			escalationTimer = setTimeout(() => {
+				if (!proc.killed) {
+					try {
+						if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+					} catch {
+						try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+					}
+				}
+			}, 5_000);
+		};
+
 		// Timeout enforcement
 		const timer = setTimeout(() => {
 			killed = true;
-			proc.kill("SIGTERM");
-			setTimeout(() => {
-				if (!proc.killed) proc.kill("SIGKILL");
-			}, 5_000);
+			killCleaveProc(proc);
+			scheduleEscalation();
 		}, timeoutMs);
 
-		// Abort signal support
+		// Abort signal support (with SIGKILL escalation — detached processes
+		// won't receive SIGHUP on parent exit, so SIGTERM alone is insufficient)
 		const onAbort = () => {
 			killed = true;
-			proc.kill("SIGTERM");
+			killCleaveProc(proc);
+			scheduleEscalation();
 		};
 		signal?.addEventListener("abort", onAbort, { once: true });
 
+		let settled = false;
 		proc.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
 			clearTimeout(timer);
+			clearTimeout(escalationTimer);
 			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				exitCode: killed ? -1 : (code ?? 1),
@@ -444,7 +466,11 @@ async function spawnChild(
 		});
 
 		proc.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
 			clearTimeout(timer);
+			clearTimeout(escalationTimer);
 			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				exitCode: 1,

package/extensions/cleave/index.ts

@@ -20,6 +20,7 @@ import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "
 import { Text } from "@styrene-lab/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { spawn, execFile } from "node:child_process";
+import { registerCleaveProc, deregisterCleaveProc, killCleaveProc, killAllCleaveSubprocesses } from "./subprocess-tracker.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
@@ -766,12 +767,14 @@ async function runSpecAssessmentSubprocess(
 			cwd: input.repoPath,
 			shell: false,
 			stdio: ["pipe", "pipe", "pipe"],
+			detached: true,
 			env: {
 				...process.env,
 				PI_CHILD: "1",
 				TERM: process.env.TERM ?? "dumb",
 			},
 		});
+		registerCleaveProc(proc);
 		let stdout = "";
 		let stderr = "";
 		let buffer = "";
@@ -789,10 +792,17 @@ async function runSpecAssessmentSubprocess(
 			clearTimeout(timer);
 			resolve(value);
 		};
+		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
 		const timer = setTimeout(() => {
-			proc.kill("SIGTERM");
-			setTimeout(() => {
-				if (!proc.killed) proc.kill("SIGKILL");
+			killCleaveProc(proc);
+			escalationTimer = setTimeout(() => {
+				if (!proc.killed) {
+					try {
+						if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+					} catch {
+						try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+					}
+				}
 			}, 5_000);
 			settleReject(new Error(`Timed out after 120s while assessing ${input.changeName}.`));
 		}, 120_000);
@@ -823,9 +833,13 @@ async function runSpecAssessmentSubprocess(
 			stderr += data.toString();
 		});
 		proc.on("error", (error) => {
+			deregisterCleaveProc(proc);
+			clearTimeout(escalationTimer);
 			settleReject(error);
 		});
 		proc.on("close", (code) => {
+			deregisterCleaveProc(proc);
+			clearTimeout(escalationTimer);
 			if (buffer.trim()) processLine(buffer.trim());
 			if ((code ?? 1) !== 0) {
 				settleReject(new Error(stderr.trim() || `Assessment subprocess exited with code ${code ?? 1}.`));
@@ -1688,6 +1702,10 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 		}
 	});
 
+	// ── Subprocess cleanup on session exit ───────────────────────────────
+	pi.on("session_shutdown", () => {
+		killAllCleaveSubprocesses();
+	});
 
 	// ── cleave_assess tool ───────────────────────────────────────────────
 	pi.registerTool({

package/extensions/cleave/subprocess-tracker.ts

@@ -0,0 +1,72 @@
+/**
+ * cleave/subprocess-tracker — Process registry for cleave subprocesses.
+ *
+ * Mirrors the extraction-v2 pattern: all spawned child processes are tracked
+ * in a Set, killed by process group (SIGTERM to -pid), and cleaned up on
+ * session_shutdown. Prevents orphaned `pi` processes when assessments time
+ * out or sessions exit mid-dispatch.
+ */
+
+import type { ChildProcess } from "node:child_process";
+
+const allCleaveProcs = new Set<ChildProcess>();
+
+/** Kill a single subprocess by process group, with fallback to direct kill. */
+export function killCleaveProc(proc: ChildProcess): void {
+	try {
+		if (proc.pid) process.kill(-proc.pid, "SIGTERM");
+	} catch {
+		try { proc.kill("SIGTERM"); } catch { /* already dead */ }
+	}
+}
+
+/** Add a subprocess to the tracked set. */
+export function registerCleaveProc(proc: ChildProcess): void {
+	allCleaveProcs.add(proc);
+}
+
+/** Remove a subprocess from the tracked set. */
+export function deregisterCleaveProc(proc: ChildProcess): void {
+	allCleaveProcs.delete(proc);
+}
+
+/**
+ * Force-kill a single subprocess (SIGKILL) by process group, with fallback.
+ * Used for escalation when SIGTERM is ignored.
+ */
+function forceKillCleaveProc(proc: ChildProcess): void {
+	try {
+		if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+	} catch {
+		try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+	}
+}
+
+/**
+ * Kill all tracked cleave subprocesses and clear the registry.
+ * Sends SIGTERM immediately, then SIGKILL after 5 seconds to any survivors.
+ * Because cleave subprocesses are spawned with `detached: true`, they will
+ * NOT receive SIGHUP when the parent exits — SIGKILL escalation is required.
+ */
+export function killAllCleaveSubprocesses(): void {
+	const snapshot = [...allCleaveProcs];
+	for (const proc of snapshot) {
+		killCleaveProc(proc);
+	}
+	// Escalate: SIGKILL after 5s for any process that ignored SIGTERM.
+	// The timer is unref'd so it does not keep the Node.js event loop alive.
+	if (snapshot.length > 0) {
+		const escalation = setTimeout(() => {
+			for (const proc of snapshot) {
+				if (!proc.killed) forceKillCleaveProc(proc);
+			}
+		}, 5_000);
+		escalation.unref();
+	}
+	allCleaveProcs.clear();
+}
+
+/** Number of currently tracked subprocesses (for diagnostics). */
+export function cleaveTrackedProcCount(): number {
+	return allCleaveProcs.size;
+}