@gajae-code/coding-agent 0.5.2 → 0.5.4

package/src/eval/py/kernel.ts

@@ -3,8 +3,9 @@
  *
  * Speaks NDJSON with `runner.py` over stdin/stdout. One subprocess per kernel
  * instance; sessions reuse a single subprocess across executions. Cancellation
- * is `kill("SIGINT")` which raises a real `KeyboardInterrupt` inside user
- * code. Shutdown writes `{"type":"exit"}` and escalates to SIGTERM/SIGKILL on
+ * sends SIGINT to the runner process group, which raises a real
+ * `KeyboardInterrupt` inside user code and any foreground magic subprocess.
+ * Shutdown writes `{"type":"exit"}` and escalates to SIGTERM/SIGKILL on
  * timeout.
  */
 import * as fs from "node:fs";
@@ -173,6 +174,7 @@ interface PendingExecution {
 	kernelKilled: boolean;
 	settled: boolean;
 	escalationTimer?: NodeJS.Timeout;
+	finalize?: () => void;
 }
 
 export class PythonKernel {
@@ -227,6 +229,9 @@ export class PythonKernel {
 			stdout: "pipe",
 			stderr: "pipe",
 			windowsHide: true,
+			// Run as its own session/process-group leader so SIGINT/SIGTERM can be
+			// delivered to the whole runner tree (incl. foreground magic subprocesses).
+			detached: true,
 		});
 		kernel.#proc = proc;
 		kernel.#stdin = proc.stdin;
@@ -377,10 +382,30 @@ export class PythonKernel {
 
 	async interrupt(): Promise<void> {
 		if (!this.#proc || this.#disposed) return;
+		this.#signalProcessGroup("SIGINT");
+	}
+
+	#signalProcessGroup(signal: NodeJS.Signals): void {
+		const proc = this.#proc;
+		if (!proc) return;
+		try {
+			if (process.platform !== "win32") {
+				process.kill(-proc.pid, signal);
+				return;
+			}
+		} catch (err) {
+			logger.warn("Failed to signal python runner process group", {
+				signal,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
 		try {
-			this.#proc.kill("SIGINT");
+			proc.kill(signal);
 		} catch (err) {
-			logger.warn("Failed to interrupt python runner", { error: err instanceof Error ? err.message : String(err) });
+			logger.warn("Failed to signal python runner", {
+				signal,
+				error: err instanceof Error ? err.message : String(err),
+			});
 		}
 	}
 
@@ -412,24 +437,16 @@ export class PythonKernel {
 
 		const exited = this.#waitForExitWithTimeout(timeoutMs);
 		let result = await exited;
-		if (!result) {
-			try {
-				proc.kill("SIGTERM");
-			} catch {
-				/* ignore */
-			}
+		if (result === null) {
+			this.#signalProcessGroup("SIGTERM");
 			result = await this.#waitForExitWithTimeout(timeoutMs);
 		}
-		if (!result) {
-			try {
-				proc.kill("SIGKILL");
-			} catch {
-				/* ignore */
-			}
+		if (result === null) {
+			this.#signalProcessGroup("SIGKILL");
 			result = await this.#waitForExitWithTimeout(timeoutMs);
 		}
 
-		const confirmed = !!result;
+		const confirmed = result !== null;
 		this.#shutdownConfirmed = confirmed;
 		this.#disposed = true;
 		return { confirmed };
@@ -441,17 +458,21 @@ export class PythonKernel {
 		this.#pending.clear();
 		const kernelKilledDefault = options?.kernelKilled ?? false;
 		for (const entry of pending) {
+			entry.cancelled = true;
+			entry.status = "error";
+			entry.kernelKilled = entry.kernelKilled || kernelKilledDefault;
+			entry.finalize?.();
 			if (entry.settled) continue;
 			entry.settled = true;
 			void entry.options?.onChunk?.(`[kernel] ${reason}\n`);
 			entry.resolve({
-				status: "error",
-				cancelled: true,
+				status: entry.status,
+				cancelled: entry.cancelled,
 				timedOut: entry.timedOut,
 				stdinRequested: entry.stdinRequested,
 				executionCount: entry.executionCount,
 				error: entry.error,
-				kernelKilled: entry.kernelKilled || kernelKilledDefault,
+				kernelKilled: entry.kernelKilled,
 			});
 		}
 	}
@@ -655,11 +676,14 @@ export class PythonKernel {
 	#waitForExitWithTimeout(timeoutMs: number): Promise<number | null> {
 		if (!this.#exitedPromise) return Promise.resolve(0);
 		const exitedPromise = this.#exitedPromise;
-		const timeout = new Promise<null>(resolve => {
+		return new Promise(resolve => {
 			const timer = setTimeout(() => resolve(null), Math.max(0, timeoutMs));
 			timer.unref?.();
+			exitedPromise.then(code => {
+				clearTimeout(timer);
+				resolve(code);
+			});
 		});
-		return Promise.race([exitedPromise.then(code => code as number | null), timeout]);
 	}
 }
 

package/src/eval/py/runner.py

@@ -290,6 +290,44 @@ def _emit_status(op: str, **data: Any) -> None:
     _emit({"type": "display", "id": rid, "bundle": bundle})
 
 
+def _terminate_process_group(proc: subprocess.Popen[Any]) -> None:
+    if proc.poll() is not None:
+        return
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGTERM)
+        else:
+            proc.terminate()
+    except ProcessLookupError:
+        return
+    except Exception:
+        try:
+            proc.terminate()
+        except Exception:
+            pass
+    try:
+        proc.wait(timeout=1)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGKILL)
+        else:
+            proc.kill()
+    except ProcessLookupError:
+        return
+    except Exception:
+        try:
+            proc.kill()
+        except Exception:
+            pass
+    try:
+        proc.wait(timeout=1)
+    except Exception:
+        pass
+
+
 @line_magic("pip")
 def _magic_pip(args: str) -> None:
     argv = shlex.split(args) if args else ["--help"]
@@ -300,18 +338,26 @@ def _magic_pip(args: str) -> None:
         stderr=subprocess.STDOUT,
         text=True,
         bufsize=1,
+        start_new_session=(os.name == "posix"),
     )
     installed_packages: list[str] = []
-    assert proc.stdout is not None
-    for raw_line in proc.stdout:
-        sys.stdout.write(raw_line)
-        m = re.search(r"Successfully installed\s+(.+)$", raw_line)
-        if m:
-            for token in m.group(1).split():
-                # Token is name-version; drop the version suffix.
-                pkg = token.rsplit("-", 1)[0]
-                installed_packages.append(pkg.replace("_", "-"))
-    proc.wait()
+    try:
+        assert proc.stdout is not None
+        try:
+            for raw_line in proc.stdout:
+                sys.stdout.write(raw_line)
+                m = re.search(r"Successfully installed\s+(.+)$", raw_line)
+                if m:
+                    for token in m.group(1).split():
+                        # Token is name-version; drop the version suffix.
+                        pkg = token.rsplit("-", 1)[0]
+                        installed_packages.append(pkg.replace("_", "-"))
+        finally:
+            proc.stdout.close()
+        proc.wait()
+    except KeyboardInterrupt:
+        _terminate_process_group(proc)
+        raise
     if installed_packages:
         import importlib
 
@@ -500,11 +546,19 @@ def _run_shell_body(body: str, *, shell_arg: str) -> int:
         stderr=subprocess.STDOUT,
         text=True,
         bufsize=1,
+        start_new_session=(os.name == "posix"),
     )
-    assert proc.stdout is not None
-    for raw_line in proc.stdout:
-        sys.stdout.write(raw_line)
-    proc.wait()
+    try:
+        assert proc.stdout is not None
+        try:
+            for raw_line in proc.stdout:
+                sys.stdout.write(raw_line)
+        finally:
+            proc.stdout.close()
+        proc.wait()
+    except KeyboardInterrupt:
+        _terminate_process_group(proc)
+        raise
     return proc.returncode
 
 

package/src/exec/bash-executor.ts

@@ -32,6 +32,8 @@ export interface BashExecutorOptions {
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
+	/** Execute without retaining a native Shell in the persistent session registry. */
+	oneShot?: boolean;
 	/**
 	 * Invoked when the native minimizer rewrote the command's output, giving
 	 * the caller a chance to persist the lossless original capture (typically
@@ -59,6 +61,8 @@ export interface BashResult {
 
 const shellSessions = new Map<string, Shell>();
 const brokenShellSessions = new Set<string>();
+const retiringShellSessions = new Set<Shell>();
+const CANCEL_CLEANUP_WAIT_MS = 250;
 
 /** Number of persistent shell sessions currently retained (owner gauge). */
 export function getShellSessionCount(): number {
@@ -76,10 +80,14 @@ export async function disposeAllShellSessions(): Promise<void> {
 	// Snapshot and drop strong references up front so concurrent callers cannot
 	// reuse a session that is being torn down, then await every native abort so
 	// shutdown/signal cleanup does not return before resources are released.
-	const sessions = [...shellSessions.values()];
+	// Include retiring shells whose JS call returned after bounded abort cleanup
+	// while the native run is still unwinding; they are no longer reusable but
+	// remain owned until their run promise settles.
+	const sessions = new Set([...shellSessions.values(), ...retiringShellSessions]);
 	shellSessions.clear();
+	retiringShellSessions.clear();
 	brokenShellSessions.clear();
-	await Promise.allSettled(sessions.map(session => session.abort()));
+	await Promise.allSettled([...sessions].map(session => session.abort()));
 }
 
 postmortem.register("bash-executor:shell-sessions", () => disposeAllShellSessions());
@@ -151,14 +159,12 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	}
 
+	const usePersistentShell = options?.oneShot !== true;
 	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
-	const persistentSessionBroken = brokenShellSessions.has(sessionKey);
-	if (persistentSessionBroken) {
-		shellSessions.delete(sessionKey);
-	}
+	const persistentSessionBroken = usePersistentShell && brokenShellSessions.has(sessionKey);
 
-	let shellSession = persistentSessionBroken ? undefined : shellSessions.get(sessionKey);
-	if (!shellSession && !persistentSessionBroken) {
+	let shellSession = persistentSessionBroken || !usePersistentShell ? undefined : shellSessions.get(sessionKey);
+	if (!shellSession && !persistentSessionBroken && usePersistentShell) {
 		shellSession = new Shell({
 			sessionEnv: shellEnv,
 			snapshotPath: snapshotPath ?? undefined,
@@ -172,16 +178,29 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (!runAbortController.signal.aborted) {
 			runAbortController.abort();
 		}
-		if (shellSession) {
-			// Native abort is async; fire-and-forget because the caller races the command separately.
-			void shellSession.abort();
+		if (shellSession && !abortPromise) {
+			abortPromise = shellSession.abort();
 		}
 	};
 	const abortDeferred = Promise.withResolvers<"abort">();
+	let abortPromise: Promise<unknown> | undefined;
 	const abortHandler = () => {
 		abortCurrentExecution();
 		abortDeferred.resolve("abort");
 	};
+	const awaitAbortCleanup = async (runPromise: Promise<unknown>): Promise<boolean> => {
+		const settled = await Promise.race([
+			runPromise.then(
+				() => true,
+				() => true,
+			),
+			Bun.sleep(CANCEL_CLEANUP_WAIT_MS).then(() => false),
+		]);
+		if (abortPromise) {
+			await Promise.race([abortPromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
+		}
+		return settled;
+	};
 	if (userSignal) {
 		userSignal.addEventListener("abort", abortHandler, { once: true });
 	}
@@ -198,6 +217,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	}
 
 	let resetSession = false;
+	let runSettled = false;
 
 	try {
 		const runPromise = shellSession
@@ -243,8 +263,24 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			acceptingChunks = false;
 			if (shellSession) {
 				resetSession = true;
+				retiringShellSessions.add(shellSession);
 				brokenShellSessions.add(sessionKey);
-				void runPromise.finally(() => brokenShellSessions.delete(sessionKey)).catch(() => undefined);
+				shellSessions.delete(sessionKey);
+				runSettled = await awaitAbortCleanup(runPromise);
+				if (runSettled) {
+					brokenShellSessions.delete(sessionKey);
+					retiringShellSessions.delete(shellSession);
+				} else {
+					void runPromise
+						.finally(() => {
+							brokenShellSessions.delete(sessionKey);
+							retiringShellSessions.delete(shellSession);
+							if (shellSessions.get(sessionKey) === shellSession) {
+								shellSessions.delete(sessionKey);
+							}
+						})
+						.catch(() => undefined);
+				}
 			} else {
 				void runPromise.catch(() => undefined);
 			}
@@ -337,7 +373,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (userSignal) {
 			userSignal.removeEventListener("abort", abortHandler);
 		}
-		if (resetSession) {
+		if (resetSession && runSettled && shellSessions.get(sessionKey) === shellSession) {
 			shellSessions.delete(sessionKey);
 		}
 	}

package/src/gjc-runtime/deep-interview-runtime.ts

@@ -124,8 +124,8 @@ interface ResolvedDeepInterviewArgs {
 }
 
 interface DeepInterviewLanguagePreference {
-	code: "en" | "ko";
-	label: "English" | "Korean";
+	code: "en" | "user";
+	label: "English" | "User language";
 	source: "explicit-user-request" | "initial-idea";
 	instruction: string;
 }
@@ -239,21 +239,22 @@ function englishLanguagePreference(): DeepInterviewLanguagePreference {
 	};
 }
 
+function userLanguagePreference(): DeepInterviewLanguagePreference {
+	return {
+		code: "user",
+		label: "User language",
+		source: "initial-idea",
+		instruction:
+			"Ask every user-facing deep-interview question in the user/session language inferred from the initial idea unless the user explicitly requests another language. Keep code identifiers, file paths, commands, settings/JSON keys, library/API names, and quoted source text unchanged when appropriate.",
+	};
+}
+
 function resolveDeepInterviewLanguagePreference(idea: string): DeepInterviewLanguagePreference | undefined {
 	if (/\b(?:answer|ask|respond|reply|write|use|speak)\s+(?:only\s+)?in\s+English\b/i.test(idea)) {
 		return englishLanguagePreference();
 	}
-	if (/(?:영어로|영문으로|영어\s*(?:질문|답변|응답)|English\s+only)/i.test(idea)) {
-		return englishLanguagePreference();
-	}
-	if (/\p{Script=Hangul}/u.test(idea)) {
-		return {
-			code: "ko",
-			label: "Korean",
-			source: "initial-idea",
-			instruction:
-				"Ask every user-facing deep-interview question in Korean unless the user explicitly requests another language.",
-		};
+	if (/[^\p{Script=Latin}\p{Script=Common}\p{Script=Inherited}]/u.test(idea)) {
+		return userLanguagePreference();
 	}
 	return undefined;
 }

package/src/gjc-runtime/ralplan-runtime.ts

@@ -13,6 +13,7 @@ import {
 } from "./ledger-event-renderer";
 import { isRestrictedRoleAgentBash } from "./restricted-role-agent-bash";
 import { migrateWorkflowState } from "./state-migrations";
+import { runNativeStateCommand } from "./state-runtime";
 import {
 	appendJsonlIdempotent,
 	readExistingStateForMutation,
@@ -104,6 +105,10 @@ export function isRalplanArtifactWriteInvocation(args: readonly string[]): boole
 	return hasFlag(args, "--write");
 }
 
+function isRalplanDoctorInvocation(args: readonly string[]): boolean {
+	return args[0] === "doctor";
+}
+
 function assertSafePathComponent(value: string, label: string): void {
 	if (!PATH_COMPONENT_RE.test(value) || value.includes("..")) {
 		throw new RalplanCommandError(2, `invalid path component for --${label}: ${value}`);
@@ -854,10 +859,15 @@ async function handleConsensusHandoff(args: readonly string[], cwd: string): Pro
 	return { status: 0, stdout };
 }
 
+async function handleDoctor(args: readonly string[], cwd: string): Promise<RalplanCommandResult> {
+	return await runNativeStateCommand(["doctor", "--skill", "ralplan", ...args.slice(1)], cwd);
+}
+
 /* -------------------------------- entry --------------------------------- */
 
 export async function runNativeRalplanCommand(args: string[], cwd = process.cwd()): Promise<RalplanCommandResult> {
 	try {
+		if (isRalplanDoctorInvocation(args)) return await handleDoctor(args, cwd);
 		if (isRalplanArtifactWriteInvocation(args)) return await handleArtifactWrite(args, cwd);
 		return await handleConsensusHandoff(args, cwd);
 	} catch (error) {

package/src/gjc-runtime/state-runtime.ts

@@ -450,6 +450,52 @@ function activeFlag(value: unknown): boolean {
 	return isPlainObject(value) && value.active !== false;
 }
 
+function phaseFromActiveValue(value: unknown): string | undefined {
+	if (!isPlainObject(value) || typeof value.phase !== "string") return undefined;
+	const phase = value.phase.trim();
+	return phase || undefined;
+}
+
+const RALPLAN_CANONICAL_PHASE_OVERRIDES = new Set([
+	"final",
+	"handoff",
+	"complete",
+	"completed",
+	"failed",
+	"cancelled",
+	"canceled",
+	"inactive",
+]);
+
+function modeStatePhase(value: unknown): string | undefined {
+	if (!isPlainObject(value) || typeof value.current_phase !== "string") return undefined;
+	const phase = value.current_phase.trim();
+	if (!phase) return undefined;
+	if (value.active === false && !RALPLAN_CANONICAL_PHASE_OVERRIDES.has(phase)) return undefined;
+	return phase;
+}
+
+function pushPhaseDriftProblem(options: {
+	problems: DoctorProblem[];
+	pathValue: string;
+	skill: CanonicalGjcWorkflowSkill;
+	entryKind: "active entry" | "active snapshot";
+	entrySkill: string;
+	entryPhase: string | undefined;
+	statePhase: string | undefined;
+}): void {
+	if (!options.entryPhase || !options.statePhase || options.entryPhase === options.statePhase) return;
+	options.problems.push(
+		doctorProblem(
+			"stale_active_state",
+			options.pathValue,
+			`${options.entryKind} for ${options.entrySkill} phase ${options.entryPhase} differs from canonical mode-state phase ${options.statePhase}`,
+			`gjc state ${options.skill} clear`,
+			options.skill,
+		),
+	);
+}
+
 async function collectDoctorSummary(
 	cwd: string,
 	skill: CanonicalGjcWorkflowSkill | undefined,
@@ -460,6 +506,7 @@ async function collectDoctorSummary(
 	const problems: DoctorProblem[] = [];
 	let filesScanned = 0;
 	let journalsScanned = 0;
+	const invalidModeStates = new Set<string>();
 
 	for (const currentSkill of skills) {
 		const filePath = modeStateFile(cwd, currentSkill, sessionId);
@@ -476,6 +523,7 @@ async function collectDoctorSummary(
 					currentSkill,
 				),
 			);
+			invalidModeStates.add(currentSkill);
 			continue;
 		}
 		const validation = validateWorkflowStateEnvelope(currentSkill, raw.value);
@@ -489,6 +537,7 @@ async function collectDoctorSummary(
 					currentSkill,
 				),
 			);
+			invalidModeStates.add(currentSkill);
 		}
 		const mismatch = await detectWorkflowEnvelopeIntegrityMismatch(filePath);
 		if (mismatch) {
@@ -501,6 +550,7 @@ async function collectDoctorSummary(
 					currentSkill,
 				),
 			);
+			invalidModeStates.add(currentSkill);
 		}
 	}
 
@@ -553,6 +603,17 @@ async function collectDoctorSummary(
 					),
 				);
 			}
+			if (canonical && activeFlag(entry.value) && !invalidModeStates.has(canonical)) {
+				pushPhaseDriftProblem({
+					problems,
+					pathValue: entryPath,
+					skill: canonical,
+					entryKind: "active entry",
+					entrySkill,
+					entryPhase: phaseFromActiveValue(entry.value),
+					statePhase: modeStatePhase(state.value),
+				});
+			}
 		}
 		if (isPlainObject(snapshot.value)) {
 			const activeSkills = Array.isArray(snapshot.value.active_skills) ? snapshot.value.active_skills : [];
@@ -572,6 +633,18 @@ async function collectDoctorSummary(
 						),
 					);
 				}
+				if (canonical && activeFlag(entry) && !invalidModeStates.has(canonical)) {
+					const state = await readRawJson(modeStateFile(cwd, canonical, scopeSessionId));
+					pushPhaseDriftProblem({
+						problems,
+						pathValue: snapshotPath,
+						skill: canonical,
+						entryKind: "active snapshot",
+						entrySkill,
+						entryPhase: phaseFromActiveValue(entry),
+						statePhase: modeStatePhase(state.value),
+					});
+				}
 			}
 		}
 	};