@gajae-code/coding-agent 0.13.0 → 0.13.2

package/src/edit/index.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import { $pickenv, prompt } from "@gajae-code/utils";
+import { prompt } from "@gajae-code/utils";
 import type * as z from "zod/v4";
 import {
 	executeHashlineSingle,
@@ -22,7 +22,7 @@ import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
-import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
+import { type EditMode, resolveEditMode, resolveForcedEnvEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
@@ -132,19 +132,6 @@ type EditModeDefinition = {
 	) => Promise<AgentToolResult<EditToolResultDetails, TInput>>;
 };
 
-function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
-	if (!rawEditMode || rawEditMode === "auto") {
-		return undefined;
-	}
-
-	const editMode = normalizeEditMode(rawEditMode);
-	if (!editMode) {
-		throw new Error(`Invalid PI_EDIT_VARIANT: ${rawEditMode}`);
-	}
-
-	return editMode;
-}
-
 function resolveAllowFuzzy(session: ToolSession, rawValue: string): boolean {
 	switch (rawValue) {
 		case "true":
@@ -347,15 +334,15 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #allowFuzzy: boolean;
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
-	readonly #editMode?: EditMode;
 	readonly #vimTool: VimTool;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
 
 	constructor(private readonly session: ToolSession) {
 		const { PI_EDIT_FUZZY: editFuzzy = "auto", PI_EDIT_FUZZY_THRESHOLD: editFuzzyThreshold = "auto" } = Bun.env;
-		const envEditVariant = $pickenv("GJC_EDIT_VARIANT", "PI_EDIT_VARIANT") ?? "auto";
 
-		this.#editMode = resolveConfiguredEditMode(envEditVariant);
+		// Fail fast on an invalid forced env variant; the shared resolver owns
+		// env precedence at resolution time (no separate cache here).
+		resolveForcedEnvEditMode();
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
 		this.#writethrough = createEditWritethrough(session);
@@ -363,7 +350,6 @@ export class EditTool implements AgentTool<TInput> {
 	}
 
 	get mode(): EditMode {
-		if (this.#editMode) return this.#editMode;
 		return resolveEditMode(this.session);
 	}
 

package/src/edit/renderer.ts

@@ -356,8 +356,8 @@ export const editToolRenderer = {
 		});
 		const firstEdit = Array.isArray(editArgs.edits) && editArgs.edits.length > 0 ? editArgs.edits[0] : undefined;
 		const rawPath = inventory.paths[0] ?? "";
-		const rename = editArgs.rename || firstEdit?.rename || firstEdit?.move;
-		const op = editArgs.op || firstEdit?.op || inventory.firstOp;
+		const rename = editArgs.rename || firstEdit?.rename || firstEdit?.move || inventory.rename;
+		const op = editArgs.op || firstEdit?.op || inventory.op;
 		const { description } = formatEditDescription(rawPath, uiTheme, options.expanded ? { rename } : undefined);
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
@@ -416,6 +416,7 @@ function resolveCompletedEditIdentity(
 	const firstEdit = args?.edits?.[0];
 	const inventory = getEditRequestTargetInventory(args, editMode, { isPartial });
 	const detailsPath = details && "path" in details ? details.path : undefined;
+
 	return {
 		path: detailsPath ?? args?.file_path ?? args?.path ?? firstEdit?.path ?? inventory.paths[0] ?? "",
 		op: details?.op ?? args?.op ?? firstEdit?.op,

package/src/edit/streaming.ts

@@ -31,7 +31,7 @@ import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { computePatchDiff, type Operation, type PatchEditEntry } from "./modes/patch";
+import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 
 export interface PerFileDiffPreview {
@@ -76,11 +76,11 @@ export interface EditStreamingStrategy<Args = unknown> {
 }
 export interface EditRequestTargetInventory {
 	paths: string[];
-	/** Operation of the first target (Create/Delete) when derivable from the
-	 * request payload (apply_patch/hashline free-form envelopes carry op on the
-	 * parsed entry, not on the top-level args). */
-	firstOp?: Operation;
 	parseError?: string;
+	/** First envelope entry operation, for free-form modes that carry no structured `edits`. */
+	op?: PatchEditEntry["op"];
+	/** First envelope entry rename target, for free-form modes that carry no structured `edits`. */
+	rename?: string;
 }
 const MISSING_APPLY_PATCH_END_ERROR = `The last line of the patch must be '${END_PATCH_MARKER}'`;
 
@@ -135,6 +135,19 @@ function getHashlineTargetPaths(input: string): string[] {
 	return paths.filter(Boolean);
 }
 
+/**
+ * `apply_patch` carries operation metadata inside the envelope rather than in structured `edits`,
+ * so the collapsed card has to read op/rename off the first parsed entry to stay accurate while live.
+ */
+function applyPatchEntryInventory(entries: readonly ApplyPatchEntry[]): EditRequestTargetInventory {
+	const first = entries[0];
+	return {
+		paths: orderedDistinctPaths(entries.map(entry => entry.path)),
+		op: first?.op,
+		rename: first?.rename,
+	};
+}
+
 export function getEditRequestTargetInventory(
 	args: unknown,
 	editMode: EditMode | undefined,
@@ -154,22 +167,22 @@ export function getEditRequestTargetInventory(
 	if (editMode === "hashline") {
 		const input = typeof values.input === "string" ? values.input : "";
 		const headerPaths = getHashlineTargetPaths(input);
-		return { paths: orderedDistinctPaths(headerPaths.length > 0 ? headerPaths : [topLevelPath]) };
+		// `path` is only a fallback for headerless input; explicit §PATH headers are the full target set.
+		if (headerPaths.length > 0) return { paths: orderedDistinctPaths(headerPaths) };
+		return { paths: orderedDistinctPaths([topLevelPath]) };
 	}
 
-	if (editMode === "apply_patch") {
+	// Legacy call sites render the shared edit card without threading `renderContext.editMode`;
+	// a free-form `input` string is only ever an apply_patch envelope there.
+	if (editMode === "apply_patch" || (editMode === undefined && typeof values.input === "string")) {
 		const input = typeof values.input === "string" ? values.input : "";
 		try {
-			const entries = expandApplyPatchToEntries({ input });
-			return { paths: orderedDistinctPaths(entries.map(entry => entry.path)), firstOp: entries[0]?.op };
+			return applyPatchEntryInventory(expandApplyPatchToEntries({ input }));
 		} catch (err) {
 			const parseError = err instanceof Error ? err.message : String(err);
-			const previewEntries = expandApplyPatchToPreviewEntries({ input });
-			const paths = orderedDistinctPaths(previewEntries.map(entry => entry.path));
-			if (options.isPartial && parseError === MISSING_APPLY_PATCH_END_ERROR) {
-				return { paths, firstOp: previewEntries[0]?.op };
-			}
-			return { paths, firstOp: previewEntries[0]?.op, parseError };
+			const inventory = applyPatchEntryInventory(expandApplyPatchToPreviewEntries({ input }));
+			if (options.isPartial && parseError === MISSING_APPLY_PATCH_END_ERROR) return inventory;
+			return { ...inventory, parseError };
 		}
 	}
 

package/src/eval/py/executor.ts

@@ -116,6 +116,7 @@ interface PythonSession {
 interface InitializingPythonSession {
 	sessionId: string;
 	promise: Promise<PythonSession>;
+	cancelled?: PythonExecutionCancelledError;
 }
 
 let pythonResourceCleanupRegistered = false;
@@ -126,6 +127,14 @@ function ensurePythonResourceCleanup(): void {
 	registerResourceOwner("python-kernel-sessions", disposeAllKernelSessions);
 }
 const sessions = new Map<string, PythonSession | InitializingPythonSession>();
+const retiringKernels = new Set<PythonKernel>();
+
+async function shutdownOrRetainKernel(kernel: PythonKernel): Promise<void> {
+	const result = await kernel.shutdown().catch(() => undefined);
+	if (result?.confirmed) return;
+	retiringKernels.add(kernel);
+	logger.warn("Python kernel shutdown not confirmed", { kernelId: kernel.id });
+}
 
 function isInitializingSession(
 	session: PythonSession | InitializingPythonSession,
@@ -312,9 +321,23 @@ function attachOwner(session: PythonSession, sessionId: string, ownerId: string
 async function acquireSession(sessionId: string, cwd: string, options: PythonExecutorOptions): Promise<PythonSession> {
 	const existing = sessions.get(sessionId);
 	if (existing) {
-		const session = isInitializingSession(existing)
-			? await waitForPromiseWithCancellation(existing.promise, options)
-			: existing;
+		let session: PythonSession;
+		if (isInitializingSession(existing)) {
+			try {
+				session = await waitForPromiseWithCancellation(existing.promise, options);
+			} catch (error) {
+				const remainingMs = getRemainingTimeoutMs(options.deadlineMs);
+				if (
+					isCancellationError(error) &&
+					!options.signal?.aborted &&
+					(remainingMs === undefined || remainingMs > 0)
+				)
+					return await acquireSession(sessionId, cwd, options);
+				throw error;
+			}
+		} else {
+			session = existing;
+		}
 		attachOwner(session, sessionId, options.kernelOwnerId);
 		ensurePythonResourceCleanup();
 		return session;
@@ -324,9 +347,13 @@ async function acquireSession(sessionId: string, cwd: string, options: PythonExe
 		sessionId,
 		promise: Promise.resolve().then(async () => {
 			const kernel = await startKernel(cwd, options);
+			if (initializing.cancelled) {
+				await shutdownOrRetainKernel(kernel);
+				throw initializing.cancelled;
+			}
 			const current = sessions.get(sessionId);
 			if (current !== initializing) {
-				await kernel.shutdown().catch(() => undefined);
+				await shutdownOrRetainKernel(kernel);
 				const winner = current
 					? isInitializingSession(current)
 						? await waitForPromiseWithCancellation(current.promise, options)
@@ -348,13 +375,49 @@ async function acquireSession(sessionId: string, cwd: string, options: PythonExe
 		}),
 	};
 	sessions.set(sessionId, initializing);
+	ensurePythonResourceCleanup();
+	let cancellationTimer: NodeJS.Timeout | undefined;
+	const retireCancelledInitialization = (timedOut: boolean): void => {
+		if (initializing.cancelled) return;
+		initializing.cancelled = new PythonExecutionCancelledError(timedOut);
+		if (sessions.get(sessionId) === initializing) sessions.delete(sessionId);
+	};
+	const onAbort = (): void => {
+		options.signal?.removeEventListener("abort", onAbort);
+		retireCancelledInitialization(isTimedOutCancellation(options.signal?.reason, options.signal));
+	};
+	if (options.signal?.aborted) {
+		onAbort();
+	} else if (options.signal) {
+		options.signal.addEventListener("abort", onAbort, { once: true });
+	}
+	const remainingMs = getRemainingTimeoutMs(options.deadlineMs);
+	if (remainingMs !== undefined) {
+		if (remainingMs <= 0) {
+			retireCancelledInitialization(true);
+		} else {
+			cancellationTimer = setTimeout(() => retireCancelledInitialization(true), remainingMs);
+			cancellationTimer.unref();
+		}
+	}
+	void initializing.promise
+		.finally(() => {
+			options.signal?.removeEventListener("abort", onAbort);
+			if (cancellationTimer) clearTimeout(cancellationTimer);
+		})
+		.catch(() => undefined);
 	try {
 		const session = await waitForPromiseWithCancellation(initializing.promise, options);
 		attachOwner(session, sessionId, options.kernelOwnerId);
 		ensurePythonResourceCleanup();
 		return session;
 	} catch (err) {
-		if (sessions.get(sessionId) === initializing) sessions.delete(sessionId);
+		if (isCancellationError(err)) {
+			retireCancelledInitialization(isTimedOutCancellation(err, options.signal));
+			await initializing.promise.catch(() => undefined);
+		} else if (sessions.get(sessionId) === initializing) {
+			sessions.delete(sessionId);
+		}
 		throw err;
 	}
 }
@@ -429,6 +492,8 @@ async function runQueued<T>(
 
 export async function disposeAllKernelSessions(): Promise<void> {
 	const all = [...sessions.entries()];
+	const retiring = [...retiringKernels];
+	retiringKernels.clear();
 	for (const [id, session] of all) {
 		if (sessions.get(id) === session) sessions.delete(id);
 	}
@@ -450,6 +515,16 @@ export async function disposeAllKernelSessions(): Promise<void> {
 		logger.warn("Python kernel shutdown not confirmed", { sessionId: id, reason });
 		if (!sessions.has(id)) sessions.set(id, session);
 	}
+	const retiringResults = await Promise.allSettled(retiring.map(kernel => kernel.shutdown()));
+	for (let i = 0; i < retiring.length; i += 1) {
+		const result = retiringResults[i];
+		if (result.status === "fulfilled" && result.value.confirmed) continue;
+		retiringKernels.add(retiring[i]);
+		logger.warn("Python kernel shutdown not confirmed", {
+			kernelId: retiring[i].id,
+			reason: result.status === "rejected" ? result.reason : "not confirmed",
+		});
+	}
 }
 
 export async function disposeKernelSessionsByOwner(ownerId: string): Promise<void> {
@@ -596,10 +671,10 @@ async function executeWithKernel(
 }
 
 async function ensureKernelAvailable(cwd: string, options: PythonExecutorOptions): Promise<void> {
-	const availability = await waitForPromiseWithCancellation(
-		checkPythonKernelAvailability(cwd, options.runtimeOptions),
-		options,
-	);
+	const availability = await checkPythonKernelAvailability(cwd, options.runtimeOptions, {
+		signal: options.signal,
+		deadlineMs: options.deadlineMs,
+	});
 	if (!availability.ok) {
 		throw new Error(availability.reason ?? "Python kernel unavailable");
 	}
@@ -683,11 +758,28 @@ export async function executePythonWithKernel(
 export async function executePython(code: string, options?: PythonExecutorOptions): Promise<PythonResult> {
 	const cwd = options?.cwd ?? getProjectDir();
 	const deadlineMs = getExecutionDeadlineMs(options);
+	const deadlineController = deadlineMs === undefined ? undefined : new AbortController();
+	const combinedController = deadlineController && options?.signal ? new AbortController() : undefined;
+	const forwardAbort = (): void => combinedController?.abort(options?.signal?.reason);
+	if (combinedController) {
+		if (options?.signal?.aborted) forwardAbort();
+		else options?.signal?.addEventListener("abort", forwardAbort, { once: true });
+	}
+	const forwardDeadlineAbort = (): void => combinedController?.abort(deadlineController?.signal.reason);
+	if (combinedController && deadlineController)
+		deadlineController.signal.addEventListener("abort", forwardDeadlineAbort, { once: true });
+	const signal = combinedController?.signal ?? deadlineController?.signal ?? options?.signal;
+	const remainingMs = getRemainingTimeoutMs(deadlineMs);
+	const deadlineTimer =
+		deadlineController && remainingMs !== undefined
+			? setTimeout(() => deadlineController.abort(new PythonExecutionCancelledError(true)), Math.max(0, remainingMs))
+			: undefined;
+	deadlineTimer?.unref();
 	const executionOptions: PythonExecutorOptions = {
 		...(options ?? {}),
+		signal,
 		deadlineMs,
 	};
-
 	try {
 		requireRemainingTimeoutMs(deadlineMs);
 		if (executionOptions.signal?.aborted) {
@@ -708,5 +800,11 @@ export async function executePython(code: string, options?: PythonExecutorOption
 			return createCancelledPythonResult(isTimedOutCancellation(err, executionOptions.signal));
 		}
 		throw err;
+	} finally {
+		if (deadlineTimer) clearTimeout(deadlineTimer);
+		if (combinedController) {
+			options?.signal?.removeEventListener("abort", forwardAbort);
+			deadlineController?.signal.removeEventListener("abort", forwardDeadlineAbort);
+		}
 	}
 }

package/src/eval/py/kernel.ts

@@ -10,13 +10,17 @@
  */
 import { $env, isBunTestRuntime, logger, Snowflake } from "@gajae-code/utils";
 import type { Subprocess } from "bun";
-import { $ } from "bun";
 import { Settings } from "../../config/settings";
 import { type KernelDisplayOutput, renderKernelDisplay } from "./display";
 import { resolvePythonIpcTrace, resolvePythonSkipCheck } from "./env";
 import { PYTHON_PRELUDE } from "./prelude";
 import { ensureRunnerScript } from "./runner-artifact";
-import { ensurePythonRuntime, filterEnv, type PythonRuntimeOptions } from "./runtime";
+import {
+	ensurePythonRuntime,
+	filterEnv,
+	type PythonRuntimeLifecycleOptions,
+	type PythonRuntimeOptions,
+} from "./runtime";
 
 export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
 export { renderKernelDisplay } from "./display";
@@ -103,32 +107,98 @@ function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string)
 	throw createAbortError("AbortError", typeof reason === "string" ? reason : fallbackReason);
 }
 
+async function waitForLifecycle<T>(
+	value: Promise<T>,
+	lifecycle: PythonRuntimeLifecycleOptions | undefined,
+	message: string,
+): Promise<T> {
+	const { promise, resolve, reject } = Promise.withResolvers<T>();
+	const cleanups: Array<() => void> = [];
+	const finish = (callback: () => void): void => {
+		while (cleanups.length > 0) cleanups.pop()?.();
+		callback();
+	};
+	if (lifecycle?.signal?.aborted) {
+		return Promise.reject(lifecycle.signal.reason ?? createAbortError("AbortError", message));
+	}
+	if (lifecycle?.signal) {
+		const onAbort = (): void =>
+			finish(() => reject(lifecycle.signal?.reason ?? createAbortError("AbortError", message)));
+		lifecycle.signal.addEventListener("abort", onAbort, { once: true });
+		cleanups.push(() => lifecycle.signal?.removeEventListener("abort", onAbort));
+	}
+	const remainingMs = getRemainingTimeMs(lifecycle?.deadlineMs);
+	if (remainingMs !== undefined) {
+		if (remainingMs <= 0) {
+			finish(() => reject(createAbortError("TimeoutError", `${message} timed out`)));
+		} else {
+			const timer = setTimeout(
+				() => finish(() => reject(createAbortError("TimeoutError", `${message} timed out`))),
+				remainingMs,
+			);
+			timer.unref();
+			cleanups.push(() => clearTimeout(timer));
+		}
+	}
+	void value.then(
+		result => finish(() => resolve(result)),
+		error => finish(() => reject(error)),
+	);
+	return await promise;
+}
+
 export async function checkPythonKernelAvailability(
 	cwd: string,
 	runtimeOptions?: PythonRuntimeOptions,
+	lifecycle?: PythonRuntimeLifecycleOptions,
 ): Promise<PythonKernelAvailability> {
 	if (isBunTestRuntime() || resolvePythonSkipCheck($env)) {
 		return { ok: true };
 	}
+	throwIfAborted(lifecycle?.signal, "Python kernel availability check aborted");
+	if (lifecycle?.deadlineMs !== undefined && lifecycle.deadlineMs <= Date.now()) {
+		throw createAbortError("TimeoutError", "Python kernel availability check timed out");
+	}
 	try {
-		const settings = await Settings.init();
+		const settings = await waitForLifecycle(Settings.init(), lifecycle, "Python kernel settings initialization");
 		const { env } = settings.getShellConfig();
 		const baseEnv = filterEnv(env);
-		const runtime = await ensurePythonRuntime(cwd, baseEnv, runtimeOptions);
-		const probe = await $`${runtime.pythonPath} -c "import sys;sys.exit(0)"`
-			.quiet()
-			.nothrow()
-			.cwd(cwd)
-			.env(runtime.env);
-		if (probe.exitCode === 0) {
+		const runtime = await ensurePythonRuntime(cwd, baseEnv, runtimeOptions, lifecycle);
+		const probeEnv: Record<string, string> = {};
+		for (const [key, value] of Object.entries(runtime.env)) {
+			if (typeof value === "string") probeEnv[key] = value;
+		}
+		const remainingMs = getRemainingTimeMs(lifecycle?.deadlineMs);
+		if (remainingMs !== undefined && remainingMs <= 0) {
+			throw createAbortError("TimeoutError", "Python kernel availability check timed out");
+		}
+		const probe = Bun.spawn([runtime.pythonPath, "-c", "import sys;sys.exit(0)"], {
+			cwd,
+			env: probeEnv,
+			stdout: "ignore",
+			stderr: "ignore",
+			windowsHide: true,
+			signal: lifecycle?.signal,
+			timeout: remainingMs,
+		});
+		const exitCode = await probe.exited;
+		throwIfAborted(lifecycle?.signal, "Python kernel availability check aborted");
+		if (lifecycle?.deadlineMs !== undefined && lifecycle.deadlineMs <= Date.now()) {
+			throw createAbortError("TimeoutError", "Python kernel availability check timed out");
+		}
+		if (exitCode === 0) {
 			return { ok: true, pythonPath: runtime.pythonPath };
 		}
 		return {
 			ok: false,
 			pythonPath: runtime.pythonPath,
-			reason: `Python interpreter at ${runtime.pythonPath} returned exit code ${probe.exitCode}`,
+			reason: `Python interpreter at ${runtime.pythonPath} returned exit code ${exitCode}`,
 		};
 	} catch (err) {
+		throwIfAborted(lifecycle?.signal, "Python kernel availability check aborted");
+		if (lifecycle?.deadlineMs !== undefined && lifecycle.deadlineMs <= Date.now()) {
+			throw createAbortError("TimeoutError", "Python kernel availability check timed out");
+		}
 		return { ok: false, reason: err instanceof Error ? err.message : String(err) };
 	}
 }
@@ -186,6 +256,7 @@ export class PythonKernel {
 			checkPythonKernelAvailability,
 			options.cwd,
 			options.runtimeOptions,
+			{ signal: options.signal, deadlineMs: options.deadlineMs },
 		);
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
@@ -194,7 +265,10 @@ export class PythonKernel {
 		const settings = await Settings.init();
 		const { env: shellEnv } = settings.getShellConfig();
 		const baseEnv = filterEnv(shellEnv);
-		const runtime = await ensurePythonRuntime(options.cwd, baseEnv, options.runtimeOptions);
+		const runtime = await ensurePythonRuntime(options.cwd, baseEnv, options.runtimeOptions, {
+			signal: options.signal,
+			deadlineMs: options.deadlineMs,
+		});
 		const spawnEnv: Record<string, string> = {};
 		for (const [key, value] of Object.entries(runtime.env)) {
 			if (typeof value === "string") spawnEnv[key] = value;