@code-yeongyu/senpi-codemode 2026.10.5 → 2026.10.6

package/src/kernels/shared/process-group-cpu.ts

@@ -0,0 +1,139 @@
+/**
+ * CPU time a process group has used so far, read from the kernel without spawning anything, in
+ * platform units that only ever grow: the startup watchdog compares two readings and never converts.
+ *
+ * - darwin: every member from `proc_listpgrppids`, each `ri_user_time + ri_system_time` from
+ *   `proc_pid_rusage(RUSAGE_INFO_V2)` (libproc, via `bun:ffi`);
+ * - linux: every `/proc/<pid>/stat` whose process group is `pgid`, `utime + stime` in clock ticks;
+ * - darwin on a runtime without `bun:ffi` (Node): the members' `cputime` from one `ps` call, in
+ *   hundredths of a second;
+ * - win32 and anything else: `undefined`. Windows has no process groups, and the launcher's own time
+ *   misses the interpreter a launcher such as juliaup starts, so the caller treats the CPU as unknown.
+ *
+ * `bun:ffi` is fetched with `process.getBuiltinModule` so the module still loads on Node, the same
+ * runtime boundary `process-footprint.ts` in coding-agent uses. Every read is synchronous and never throws.
+ */
+import { execFileSync } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+
+type BunFfi = typeof import("bun:ffi");
+type GroupCpuReader = (pgid: number) => bigint | undefined;
+
+const RUSAGE_INFO_V2 = 2;
+const RI_USER_TIME_OFFSET = 16;
+const RI_SYSTEM_TIME_OFFSET = 24;
+const RUSAGE_BUFFER_BYTES = 256;
+const MAX_GROUP_MEMBERS = 4096;
+const PS_TIMEOUT_MS = 2_000;
+
+let groupReader: GroupCpuReader | null | undefined;
+
+export function readProcessGroupCpuTime(pgid: number): bigint | undefined {
+	if (!Number.isInteger(pgid) || pgid <= 0) return undefined;
+	if (groupReader === undefined) groupReader = createGroupReader() ?? null;
+	return groupReader?.(pgid);
+}
+
+/** `utime + stime` and the process group from `/proc/<pid>/stat` text, or `undefined` when malformed. */
+export function parseProcStat(stat: string): { readonly pgrp: number; readonly cpuTicks: bigint } | undefined {
+	// The command name may itself contain spaces or parentheses: the fields start after the last ")".
+	const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+	const pgrp = Number(fields[2]);
+	const utime = fields[11];
+	const stime = fields[12];
+	if (!Number.isInteger(pgrp) || utime === undefined || stime === undefined) return undefined;
+	if (!/^\d+$/.test(utime) || !/^\d+$/.test(stime)) return undefined;
+	return { pgrp, cpuTicks: BigInt(utime) + BigInt(stime) };
+}
+
+/** `ps` `cputime` (`[[hh:]mm:]ss.cc`) in hundredths of a second, or `undefined` when malformed. */
+export function parsePsCpuTime(text: string): bigint | undefined {
+	const match = /^(?:(\d+):)?(?:(\d+):)?(\d+)\.(\d{2})$/.exec(text.trim());
+	if (match === null) return undefined;
+	const [, first, second, seconds, hundredths] = match;
+	const hours = second === undefined ? 0 : Number(first ?? 0);
+	const minutes = second === undefined ? Number(first ?? 0) : Number(second);
+	return BigInt(((hours * 60 + minutes) * 60 + Number(seconds)) * 100 + Number(hundredths));
+}
+
+function createGroupReader(): GroupCpuReader | undefined {
+	if (process.platform === "linux") return linuxGroupReader;
+	if (process.platform !== "darwin") return undefined;
+	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	if (ffi === undefined) return darwinPsGroupReader;
+	try {
+		return darwinGroupReader(ffi);
+	} catch {
+		// A library or symbol this build cannot bind: read the group through ps instead.
+		return darwinPsGroupReader;
+	}
+}
+
+function darwinPsGroupReader(pgid: number): bigint | undefined {
+	let listing: string;
+	try {
+		listing = execFileSync("ps", ["-A", "-o", "pgid=,cputime="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+	} catch {
+		return undefined;
+	}
+	let total = 0n;
+	let members = 0;
+	for (const line of listing.split("\n")) {
+		const [group, cputime] = line.trim().split(/\s+/);
+		if (group !== String(pgid) || cputime === undefined) continue;
+		const used = parsePsCpuTime(cputime);
+		if (used === undefined) continue;
+		total += used;
+		members += 1;
+	}
+	return members === 0 ? undefined : total;
+}
+
+function linuxGroupReader(pgid: number): bigint | undefined {
+	let entries: string[];
+	try {
+		entries = readdirSync("/proc");
+	} catch {
+		return undefined;
+	}
+	let total = 0n;
+	let members = 0;
+	for (const entry of entries) {
+		if (!/^\d+$/.test(entry)) continue;
+		let stat: string;
+		try {
+			stat = readFileSync(`/proc/${entry}/stat`, "utf8");
+		} catch {
+			// The process exited between the directory read and this one.
+			continue;
+		}
+		const parsed = parseProcStat(stat);
+		if (parsed === undefined || parsed.pgrp !== pgid) continue;
+		total += parsed.cpuTicks;
+		members += 1;
+	}
+	return members === 0 ? undefined : total;
+}
+
+function darwinGroupReader({ dlopen, FFIType, ptr }: BunFfi): GroupCpuReader {
+	const library = dlopen("libSystem.B.dylib", {
+		proc_listpgrppids: { args: [FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+		proc_pid_rusage: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+	});
+	const pids = new Int32Array(MAX_GROUP_MEMBERS);
+	const usage = new Uint8Array(RUSAGE_BUFFER_BYTES);
+	const view = new DataView(usage.buffer);
+	return (pgid) => {
+		const count = library.symbols.proc_listpgrppids(pgid, ptr(pids), pids.byteLength);
+		if (count <= 0) return undefined;
+		let total = 0n;
+		let members = 0;
+		for (const pid of pids.subarray(0, Math.min(count, MAX_GROUP_MEMBERS))) {
+			usage.fill(0);
+			if (library.symbols.proc_pid_rusage(pid, RUSAGE_INFO_V2, ptr(usage)) !== 0) continue;
+			total += view.getBigUint64(RI_USER_TIME_OFFSET, true) + view.getBigUint64(RI_SYSTEM_TIME_OFFSET, true);
+			members += 1;
+		}
+		return members === 0 ? undefined : total;
+	};
+}

package/src/kernels/shared/subprocess-contract.ts

@@ -5,6 +5,7 @@ import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelLifecycle } from "./kernel-death.ts";
 import type { FootprintReader } from "./kernel-memory-host.ts";
 import type { SubprocessSpawn } from "./subprocess-process.ts";
+import type { SubprocessStartupOptions } from "./subprocess-startup.ts";
 
 export type KernelRunInput = EvalKernelRunInput;
 
@@ -29,4 +30,6 @@ export interface SubprocessKernelOptions extends KernelLifecycle {
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly memory?: SubprocessKernelMemory & { readonly language: EvalLanguage };
+	/** Fails a start that stops making progress before `ready`; absent, the kernel waits for `ready` indefinitely. */
+	readonly startup?: SubprocessStartupOptions;
 }

package/src/kernels/shared/subprocess-kernel.ts

@@ -23,6 +23,7 @@ import {
 	settlePendingRun,
 	timeoutResult,
 } from "./subprocess-run.ts";
+import { SubprocessStartupWatchdog } from "./subprocess-startup.ts";
 
 export type {
 	KernelResult,
@@ -40,6 +41,7 @@ export class SubprocessKernel {
 	private readonly memory: KernelMemoryHost | null;
 	private process: SubprocessProcess | null = null;
 	private processReady = false;
+	private startup: SubprocessStartupWatchdog | null = null;
 	private retirementPromise: Promise<void> | null = null;
 	private retirementProcess: SubprocessProcess | null = null;
 	private retirementFailure: Error | null = null;
@@ -133,6 +135,7 @@ export class SubprocessKernel {
 	async close(): Promise<void> {
 		const wasClosed = this.closed;
 		this.closed = true;
+		this.startup?.stop();
 		if (!wasClosed) {
 			this.settleAll(new KernelClosingError());
 			this.runs.clearToolCalls();
@@ -197,10 +200,21 @@ export class SubprocessKernel {
 		});
 		this.process = process;
 		this.processReady = false;
+		this.startup?.stop();
+		const startup = this.options.startup;
+		this.startup = startup
+			? new SubprocessStartupWatchdog(startup, child.pid, (message) => this.stalled(process, message))
+			: null;
 		this.memory?.processReplaced();
 		try {
+			const thresholds = this.options.memory?.thresholds;
 			process.send(
-				encodeBridgeFrame({ type: "init", sessionId: this.options.sessionId, connection: this.options.connection }),
+				encodeBridgeFrame({
+					type: "init",
+					sessionId: this.options.sessionId,
+					connection: this.options.connection,
+					...(thresholds === undefined ? {} : { memory: thresholds }),
+				}),
 			);
 		} catch (error) {
 			const failure = new KernelStartupError(error instanceof Error ? error.message : String(error));
@@ -221,7 +235,9 @@ export class SubprocessKernel {
 
 	private handleMessage(process: SubprocessProcess, message: KernelToHostMessage): void {
 		if (!this.accepts(process)) return;
+		if (!this.processReady) this.startup?.observe(message);
 		if (message.type === "ready") {
+			this.startup?.stop();
 			this.processReady = true;
 			this.runs.handleMessage(message, this.onMessage);
 			this.pumpRuns();
@@ -247,6 +263,7 @@ export class SubprocessKernel {
 
 	private handleExit(process: SubprocessProcess, code: number | null, signal: NodeJS.Signals | null): void {
 		if (this.process !== process) return;
+		this.startup?.stop();
 		if (process.isRetiring) {
 			this.process = null;
 			this.retirementFailure = null;
@@ -277,6 +294,20 @@ export class SubprocessKernel {
 		onDeath(reason);
 	}
 
+	/** A stalled start is a death: the owner replaces the kernel and the cells that never started run there. */
+	private stalled(process: SubprocessProcess, message: string): void {
+		if (!this.accepts(process)) return;
+		const error = new KernelStartupError(message);
+		const onDeath = this.options.onDeath;
+		if (!onDeath) {
+			this.failClosed(error);
+			return;
+		}
+		process.retire();
+		this.trackRetirement(process, this.terminateOwnedProcess(process));
+		this.die(error, message, onDeath);
+	}
+
 	private accepts(process: SubprocessProcess): boolean {
 		return !this.closed && this.process === process && !process.isRetiring;
 	}
@@ -330,6 +361,7 @@ export class SubprocessKernel {
 	}
 
 	private failClosed(error: Error): void {
+		this.startup?.stop();
 		const process = this.process;
 		this.failure = error;
 		this.closed = true;

package/src/kernels/shared/subprocess-startup.ts

@@ -0,0 +1,90 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+
+/**
+ * How long a starting interpreter may stay completely still - no output line, no new startup stage, and
+ * no CPU used by its process group - before startup fails. A cold Julia compiling its prelude prints
+ * nothing for seconds but keeps the CPU busy, so it never trips; only a runner that is silent AND idle
+ * (blocked on a lock, a pipe or a stopped process) does. It restarts on every sign of progress, so it is
+ * not a total startup budget. Where the group's CPU cannot be read it never fires.
+ */
+export const subprocessStartupNoProgressMs = 30_000;
+
+const STDERR_TAIL_CHARS = 2_000;
+const stages = ["interpreter-launch", "stdlib-imports", "runtime-init", "host-init"] as const;
+export type SubprocessStartupStage = (typeof stages)[number];
+
+export interface SubprocessStartupOptions {
+	readonly label: string;
+	readonly noProgressMs?: number;
+	/** CPU time used so far by a process group (any unit that only grows); `undefined` when unreadable. */
+	readonly readGroupCpuTime?: (pgid: number) => bigint | undefined;
+}
+
+export class SubprocessStartupWatchdog {
+	readonly #options: SubprocessStartupOptions;
+	readonly #pid: number | undefined;
+	readonly #onStall: (message: string) => void;
+	readonly #noProgressMs: number;
+	#stageIndex = 0;
+	#stderrTail = "";
+	#lastCpu: bigint | undefined;
+	#timer: ReturnType<typeof setTimeout> | undefined;
+	#stopped = false;
+
+	constructor(options: SubprocessStartupOptions, pid: number | undefined, onStall: (message: string) => void) {
+		this.#options = options;
+		this.#pid = pid;
+		this.#onStall = onStall;
+		this.#noProgressMs = options.noProgressMs ?? subprocessStartupNoProgressMs;
+		this.#lastCpu = this.#readCpu();
+		this.#arm();
+	}
+
+	/** Any message the runner sent before `ready` is progress; a later startup stage also moves the stage. */
+	observe(message: KernelToHostMessage): void {
+		if (this.#stopped) return;
+		if (message.type === "status" && message.event.op === "kernel-startup") {
+			const stage = stages.find((candidate) => candidate === message.event.stage);
+			const next = stage === undefined ? -1 : stages.indexOf(stage);
+			if (next > this.#stageIndex) this.#stageIndex = next;
+		}
+		if (message.type === "text" && message.stream === "stderr") {
+			this.#stderrTail = (this.#stderrTail + message.data).slice(-STDERR_TAIL_CHARS);
+		}
+		this.#arm();
+	}
+
+	stop(): void {
+		this.#stopped = true;
+		clearTimeout(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#arm(): void {
+		clearTimeout(this.#timer);
+		this.#timer = setTimeout(() => this.#expire(), this.#noProgressMs);
+	}
+
+	#expire(): void {
+		if (this.#stopped) return;
+		const cpu = this.#readCpu();
+		// Unreadable CPU means busy and idle look the same: never cut a start off on silence alone.
+		// Any change counts, a drop included: a member of the group exited, which is activity.
+		if (cpu === undefined || cpu !== this.#lastCpu) {
+			this.#lastCpu = cpu;
+			this.#arm();
+			return;
+		}
+		this.stop();
+		const stage = stages[this.#stageIndex] ?? "interpreter-launch";
+		const seconds = Math.round(this.#noProgressMs / 1000);
+		const tail = this.#stderrTail.trim();
+		this.#onStall(
+			`${this.#options.label} kernel stalled at ${stage}: no output, stage change or CPU use for ${seconds} s${tail ? `; stderr: ${tail}` : ""}`,
+		);
+	}
+
+	#readCpu(): bigint | undefined {
+		return this.#pid === undefined ? undefined : this.#options.readGroupCpuTime?.(this.#pid);
+	}
+}

package/src/tool/run-eval-cell.ts

@@ -209,7 +209,7 @@ async function executeCell(
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
 		// Computed before the handler so its construction-time snapshot captures this cell's capability.
 		// Worker messages later restore that snapshot before calling host tools (#1754, #2512).
-		const kernelTools = jsKernelTools(kernel, invocation.input.language);
+		const kernelTools = kernelToolsFor(kernel);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
 			const queue = kernel.queueSnapshot();
 			state.queuedBehind = [...(queue.activeCellId === null ? [] : [queue.activeCellId]), ...queue.queuedCellIds];
@@ -292,16 +292,15 @@ async function executeCell(
 	}
 }
 
-function jsKernelTools(kernel: EvalKernel, language: string): KernelToolsCapability | undefined {
-	if (language !== "js") return undefined;
+function kernelToolsFor(kernel: EvalKernel): KernelToolsCapability | undefined {
 	if (!("describeKernelTools" in kernel) || typeof kernel.describeKernelTools !== "function") return undefined;
-	const js = kernel as EvalKernel & {
+	const withTools = kernel as EvalKernel & {
 		describeKernelTools: (names: readonly string[]) => Promise<KernelToolsDescribeResult>;
 		invokeKernelTool: ExtensionKernelTools["invoke"];
 	};
 	return {
 		capabilities: KERNEL_TOOLS_CAPABILITIES,
-		describe: (names) => js.describeKernelTools(names),
-		invoke: (request, options) => js.invokeKernelTool(request, options),
+		describe: (names) => withTools.describeKernelTools(names),
+		invoke: (request, options) => withTools.invokeKernelTool(request, options),
 	} satisfies ExtensionKernelTools;
 }