@gajae-code/coding-agent 0.13.0 → 0.13.1

package/src/config/keybindings.ts

@@ -75,8 +75,10 @@ export function defaultMessageQueueKeysForPlatform(platform: NodeJS.Platform = p
 	return platform === "win32" || platform === "darwin" ? "alt+q" : "alt+enter";
 }
 
-export function defaultClipboardPasteImageKeysForPlatform(platform: NodeJS.Platform = process.platform): KeyId {
-	return platform === "win32" ? "alt+v" : "ctrl+v";
+export function defaultClipboardPasteImageKeysForPlatform(platform: NodeJS.Platform = process.platform): KeyId[] {
+	if (platform === "darwin") return ["ctrl+v", "super+v"];
+	if (platform === "win32") return ["ctrl+v", "alt+v"];
+	return ["ctrl+v"];
 }
 
 /**

package/src/config/model-registry.ts

@@ -1223,6 +1223,7 @@ interface ModelManagerDiscoveryOptions {
  */
 export class ModelRegistry {
 	#models: Model<Api>[] = [];
+	#catalogChangeListeners: Set<() => void> = new Set();
 	#canonicalIndex: CanonicalModelIndex = {
 		records: [],
 		byId: new Map(),
@@ -1301,6 +1302,13 @@ export class ModelRegistry {
 		this.#loadModels();
 	}
 
+	onCatalogChanged(listener: () => void): () => void {
+		this.#catalogChangeListeners.add(listener);
+		return () => {
+			this.#catalogChangeListeners.delete(listener);
+		};
+	}
+
 	/**
 	 * Reload models from disk (built-in + custom from models.json).
 	 */
@@ -3250,6 +3258,7 @@ export class ModelRegistry {
 		}
 		this.#canonicalIndex = buildCanonicalModelIndex(this.#models, this.#equivalenceConfig);
 		this.#invalidateAvailableModels();
+		this.#notifyCatalogChanged();
 		this.#rebuildPending = false;
 	}
 
@@ -3259,6 +3268,16 @@ export class ModelRegistry {
 		this.#availableModelsEnvFingerprint = undefined;
 	}
 
+	#notifyCatalogChanged(): void {
+		for (const listener of [...this.#catalogChangeListeners]) {
+			try {
+				listener();
+			} catch (error) {
+				logger.debug("ModelRegistry catalog listener failed", { error: String(error) });
+			}
+		}
+	}
+
 	#suspendRebuild(): void {
 		this.#rebuildSuspended += 1;
 	}
@@ -3271,6 +3290,7 @@ export class ModelRegistry {
 			this.#rebuildPending = false;
 			this.#canonicalIndex = buildCanonicalModelIndex(this.#models, this.#equivalenceConfig);
 			this.#invalidateAvailableModels();
+			this.#notifyCatalogChanged();
 		}
 	}
 

package/src/config/models-config-schema.ts

@@ -25,6 +25,7 @@ export const ModelCompatSchema = z.object({
 	supportsDeveloperRole: z.boolean().optional(),
 	sendSessionHeaders: z.boolean().optional(),
 	supportsResponsesSessionAffinity: z.boolean().optional(),
+	supportsServiceTier: z.boolean().optional(),
 	supportsMultipleSystemMessages: z.boolean().optional(),
 	supportsReasoningEffort: z.boolean().optional(),
 	reasoningEffortMap: ReasoningEffortMapSchema.optional(),

package/src/config/settings-schema.ts

@@ -2,7 +2,7 @@ import type { Effort } from "@gajae-code/ai/model-thinking";
 import { PET_MODE_IDS, PET_SKIN_IDS, PET_SKINS } from "@gajae-code/tui/components/gajae-pet";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking-metadata";
-import { EDIT_MODES } from "../utils/edit-mode";
+import { DEFAULT_EDIT_MODE_SETTING, EDIT_MODE_SETTINGS, EDIT_MODES, type EditMode } from "../utils/edit-mode";
 import { CONFIGURABLE_SEARCH_PROVIDER_IDS } from "../web/search/types";
 import type { ModelSelectorValue } from "./model-selector-value";
 import { UPDATE_CHANNELS } from "./update-channel";
@@ -181,9 +181,7 @@ interface ArrayDef<T> {
 	ui?: UiBase;
 }
 
-interface RecordValueDef {
-	type: "model-selector-value";
-}
+type RecordValueDef = { type: "model-selector-value" } | { type: "string-enum"; values: readonly string[] };
 
 interface RecordDef<T> {
 	type: "record";
@@ -218,6 +216,7 @@ export interface ModelTagsSettings {
 const EMPTY_STRING_ARRAY: string[] = [];
 const EMPTY_MODEL_SELECTOR_RECORD: Record<string, ModelSelectorValue> = {};
 const MODEL_SELECTOR_VALUE_SCHEMA = { type: "model-selector-value" } as const;
+const EDIT_MODE_VALUE_SCHEMA = { type: "string-enum", values: EDIT_MODES } as const;
 const DEFAULT_CYCLE_ORDER: string[] = ["default"];
 const EMPTY_MODEL_TAGS_RECORD: ModelTagsSettings = {};
 const HINDSIGHT_RECALL_TYPES_DEFAULT: string[] = ["world", "experience"];
@@ -2141,14 +2140,20 @@ export const SETTINGS_SCHEMA = {
 	// Edit tool
 	"edit.mode": {
 		type: "enum",
-		values: EDIT_MODES,
-		default: "hashline",
+		values: EDIT_MODE_SETTINGS,
+		default: DEFAULT_EDIT_MODE_SETTING,
 		ui: {
 			tab: "editing",
 			label: "Edit Mode",
-			description: "Select the edit tool variant (replace, patch, hashline, vim, or apply_patch)",
+			description:
+				"Select the edit tool variant (auto routes by model family; replace, patch, hashline, vim, or apply_patch)",
 		},
 	},
+	"edit.modelVariants": {
+		type: "record",
+		default: {} as Record<string, EditMode>,
+		valueSchema: EDIT_MODE_VALUE_SCHEMA,
+	},
 
 	"edit.fuzzyMatch": {
 		type: "boolean",
@@ -3857,6 +3862,13 @@ function validArraySettingValue(value: unknown, allowedValues: readonly string[]
 	return !allowedValues || value.every(item => typeof item === "string" && allowedValues.includes(item));
 }
 
+function validRecordValue(valueSchema: RecordValueDef, value: unknown): boolean {
+	if (valueSchema.type === "model-selector-value") {
+		return typeof value === "string" || (Array.isArray(value) && value.every(item => typeof item === "string"));
+	}
+	return typeof value === "string" && valueSchema.values.includes(value);
+}
+
 function validSettingValue(definition: (typeof SETTINGS_SCHEMA)[SettingPath], value: unknown): boolean {
 	return (
 		(definition.type === "boolean" && typeof value === "boolean") ||
@@ -3897,11 +3909,8 @@ export function validateSettingPatch(patch: Record<string, unknown>): Array<{ pa
 				issues.push({ path, detail: "Setting is not a valid record sub-path." });
 				continue;
 			}
-			if (
-				parentDef.valueSchema.type === "model-selector-value" &&
-				!(typeof value === "string" || (Array.isArray(value) && value.every(item => typeof item === "string")))
-			) {
-				issues.push({ path, detail: "Expected model-selector-value." });
+			if (!validRecordValue(parentDef.valueSchema, value)) {
+				issues.push({ path, detail: `Expected ${parentDef.valueSchema.type}.` });
 			}
 			continue;
 		}
@@ -3923,11 +3932,8 @@ export function validateSettingPatch(patch: Record<string, unknown>): Array<{ pa
 		}
 		if (definition.type === "record" && "valueSchema" in definition && definition.valueSchema) {
 			for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-				if (
-					definition.valueSchema.type === "model-selector-value" &&
-					!(typeof entry === "string" || (Array.isArray(entry) && entry.every(item => typeof item === "string")))
-				) {
-					issues.push({ path: `${path}.${key}`, detail: "Expected model-selector-value." });
+				if (!validRecordValue(definition.valueSchema, entry)) {
+					issues.push({ path: `${path}.${key}`, detail: `Expected ${definition.valueSchema.type}.` });
 				}
 			}
 		}
@@ -3984,11 +3990,12 @@ export function reconcileSettingsSchema(raw: Record<string, unknown>): {
 			validSettingValue(definition, next)
 		) {
 			for (const [key, entry] of Object.entries(next as Record<string, unknown>)) {
-				if (
-					definition.valueSchema.type === "model-selector-value" &&
-					!(typeof entry === "string" || (Array.isArray(entry) && entry.every(item => typeof item === "string")))
-				) {
-					issues.push({ path: `${path}.${key}`, kind: "invalid", detail: "Expected model-selector-value." });
+				if (!validRecordValue(definition.valueSchema, entry)) {
+					issues.push({
+						path: `${path}.${key}`,
+						kind: "invalid",
+						detail: `Expected ${definition.valueSchema.type}.`,
+					});
 				}
 			}
 		}

package/src/config/settings.ts

@@ -37,7 +37,7 @@ import {
 	parseNotificationSettingsSnapshot,
 } from "../sdk/bus/config";
 import { AgentStorage } from "../session/agent-storage";
-import { type EditMode, normalizeEditMode } from "../utils/edit-mode";
+import { type EditMode, type EditVariantMatch, normalizeEditMode } from "../utils/edit-mode";
 import {
 	type AtomicYamlPatch,
 	applyAtomicYamlPatches,
@@ -77,6 +77,8 @@ export interface RawSettings {
 	[key: string]: unknown;
 }
 
+const UNSAFE_EDIT_VARIANT_PATTERNS = new Set(["__proto__", "constructor", "prototype"]);
+
 type SettingsPatch = {
 	readonly path: string;
 	readonly value: unknown | undefined;
@@ -964,14 +966,17 @@ export class Settings implements NotificationSettingsReader {
 	/**
 	 * Get the edit variant for a specific model.
 	 * Returns "patch", "replace", "hashline", "vim", "apply_patch", or null (use global default).
+	 * Skips invalid values; prefer `matchEditVariantForModel` when invalid
+	 * matches must fail closed instead of falling through.
 	 */
 	getEditVariantForModel(model: string | undefined): EditMode | null {
 		if (!model) return null;
-		const variants = (this.#merged.edit as { modelVariants?: Record<string, string> })?.modelVariants;
+		const variants = this.#editModelVariants();
 		if (!variants) return null;
-		for (const pattern in variants) {
+		for (const [pattern, rawValue] of Object.entries(variants)) {
+			if (UNSAFE_EDIT_VARIANT_PATTERNS.has(pattern)) continue;
 			if (model.includes(pattern)) {
-				const value = normalizeEditMode(variants[pattern]);
+				const value = normalizeEditMode(rawValue);
 				if (value) {
 					return value;
 				}
@@ -980,6 +985,35 @@ export class Settings implements NotificationSettingsReader {
 		return null;
 	}
 
+	/**
+	 * First matching `edit.modelVariants` rule for a model, with its raw
+	 * (unvalidated) value. The edit-mode resolver uses this discriminated
+	 * result so a matched-but-invalid value fails closed with a diagnostic
+	 * rather than silently resolving to another mode.
+	 */
+	matchEditVariantForModel(model: string | undefined): EditVariantMatch | null {
+		if (!model) return null;
+		const variants = this.#editModelVariants();
+		if (!variants) return null;
+		for (const [pattern, value] of Object.entries(variants)) {
+			if (UNSAFE_EDIT_VARIANT_PATTERNS.has(pattern)) continue;
+			if (model.includes(pattern)) {
+				return { pattern, value: String(value) };
+			}
+		}
+		return null;
+	}
+
+	#editModelVariants(): Record<string, string> | undefined {
+		const variants = (this.#merged.edit as { modelVariants?: unknown })?.modelVariants;
+		return typeof variants === "object" &&
+			variants !== null &&
+			!Array.isArray(variants) &&
+			(Object.getPrototypeOf(variants) === Object.prototype || Object.getPrototypeOf(variants) === null)
+			? (variants as Record<string, string>)
+			: undefined;
+	}
+
 	/**
 	 * Get bash interceptor rules (typed accessor for complex array config).
 	 */
@@ -2075,18 +2109,16 @@ export class Settings implements NotificationSettingsReader {
 
 			if (override === undefined) continue;
 
-			if (
+			const value =
 				typeof override === "object" &&
 				override !== null &&
 				!Array.isArray(override) &&
 				typeof baseVal === "object" &&
 				baseVal !== null &&
 				!Array.isArray(baseVal)
-			) {
-				result[key] = this.#deepMerge(baseVal as RawSettings, override as RawSettings);
-			} else {
-				result[key] = override;
-			}
+					? this.#deepMerge(baseVal as RawSettings, override as RawSettings)
+					: override;
+			Object.defineProperty(result, key, { configurable: true, enumerable: true, value, writable: true });
 		}
 		return result;
 	}

package/src/coordinator-mcp/server.ts

@@ -5,20 +5,20 @@ import * as path from "node:path";
 import { getAgentDir, isKnownSinkPeerClosedError } from "@gajae-code/utils";
 import { normalizePathForComparison, VERSION } from "@gajae-code/utils/dirs";
 
+import { withFileLock } from "../config/file-lock";
 import {
 	COORDINATOR_MCP_PROTOCOL_VERSION,
 	COORDINATOR_MCP_SERVER_NAME,
 	COORDINATOR_MCP_TOOL_NAMES,
 	type CoordinatorToolName,
 } from "../coordinator/contract";
-import { readLinuxProcStartTimeSync } from "../gjc-runtime/linux-proc";
 import { listMcpDelegateHostContexts } from "../hooks/mcp-delegate-host-context";
 import type { WorkflowGate, WorkflowGateQueryRecord } from "../modes/shared/agent-wire/workflow-gate-types";
 import type { BrokerDiscovery } from "../sdk/broker/discovery";
 import { type EnsureBrokerSettings, ensureBroker } from "../sdk/broker/ensure";
 import { lifecycleRequestTimeoutMs } from "../sdk/broker/startup-budget";
 import { UnsupportedStateVersionError } from "../sdk/broker/state-version";
-import { SdkClient, SdkClientError } from "../sdk/client/client";
+import { SdkClient, SdkClientError, type SdkSentRecord } from "../sdk/client/client";
 import { readSdkBrokerDiscovery } from "../sdk/client/discovery";
 import {
 	type ActivatedPreparedSession,
@@ -111,6 +111,16 @@ interface JsonRpcResponse {
 	error?: { code: number; message: string; data?: unknown };
 }
 
+function isLifecycleOperation(operation: string): boolean {
+	return (
+		operation === "session.create" ||
+		operation === "session.fork" ||
+		operation === "session.resume" ||
+		operation === "session.close" ||
+		operation === "session.delete"
+	);
+}
+
 function sinkErrorCode(error: unknown): string | undefined {
 	if (error === null || (typeof error !== "object" && typeof error !== "function")) return undefined;
 	try {
@@ -270,6 +280,10 @@ interface CoordinatorSessionState {
 	source: "coordinator" | "agent_session_event";
 	live: boolean | null;
 	reason: string | null;
+	last_activity_at?: string;
+	activity?: unknown;
+	active_tools?: unknown;
+	active_tool_calls?: unknown;
 }
 
 type CoordinatorEventKind =
@@ -1227,7 +1241,7 @@ function publicLifecycleReceipt(result: Record<string, unknown>, sessionId: stri
 
 function publicCoordinatorSessionState(state: CoordinatorSessionState | null): Record<string, unknown> | null {
 	if (!state) return null;
-	return {
+	const result: Record<string, unknown> = {
 		session_id: state.session_id,
 		state: state.state,
 		ready_for_input: state.ready_for_input,
@@ -1236,6 +1250,55 @@ function publicCoordinatorSessionState(state: CoordinatorSessionState | null): R
 		updated_at: state.updated_at,
 		...(typeof state.live === "boolean" ? { live: state.live } : {}),
 	};
+	const activity = asRecord(state.activity);
+	if (
+		typeof state.last_activity_at === "string" &&
+		Number.isFinite(Date.parse(state.last_activity_at)) &&
+		activity &&
+		typeof activity.sequence === "number" &&
+		Number.isSafeInteger(activity.sequence) &&
+		activity.sequence > 0 &&
+		activity.kind === "tool_execution" &&
+		(activity.phase === "started" || activity.phase === "finished") &&
+		typeof activity.tool_name === "string" &&
+		/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(activity.tool_name) &&
+		typeof activity.observed_at === "string" &&
+		Number.isFinite(Date.parse(activity.observed_at)) &&
+		typeof activity.active_tool_count === "number" &&
+		Number.isSafeInteger(activity.active_tool_count) &&
+		activity.active_tool_count >= 0
+	) {
+		result.last_activity_at = state.last_activity_at;
+		result.activity = {
+			sequence: activity.sequence,
+			kind: activity.kind,
+			phase: activity.phase,
+			tool_name: activity.tool_name,
+			observed_at: activity.observed_at,
+			...(typeof activity.started_at === "string" && Number.isFinite(Date.parse(activity.started_at))
+				? { started_at: activity.started_at }
+				: {}),
+			...(typeof activity.elapsed_ms === "number" &&
+			Number.isSafeInteger(activity.elapsed_ms) &&
+			activity.elapsed_ms >= 0
+				? { elapsed_ms: activity.elapsed_ms }
+				: {}),
+			...(activity.outcome === "succeeded" || activity.outcome === "failed" ? { outcome: activity.outcome } : {}),
+			active_tool_count: activity.active_tool_count,
+		};
+		if (Array.isArray(state.active_tools))
+			result.active_tools = state.active_tools.slice(0, 8).flatMap(value => {
+				const tool = asRecord(value);
+				return tool &&
+					typeof tool.tool_name === "string" &&
+					/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(tool.tool_name) &&
+					typeof tool.started_at === "string" &&
+					Number.isFinite(Date.parse(tool.started_at))
+					? [{ tool_name: tool.tool_name, started_at: tool.started_at }]
+					: [];
+			});
+	}
+	return result;
 }
 
 function eventTimestamp(record: Record<string, unknown>): string | null {
@@ -1828,7 +1891,8 @@ async function writeSessionStateUnlocked(
 		overwrite?: boolean;
 	} = {},
 ): Promise<CoordinatorSessionState> {
-	const previous = options.overwrite ? null : await readSessionState(namespaceDir, sessionId);
+	const existing = await readSessionState(namespaceDir, sessionId);
+	const previous = options.overwrite ? null : existing;
 	const hasCurrentTurn = Object.hasOwn(options, "currentTurnId");
 	const hasLastTurn = Object.hasOwn(options, "lastTurnId");
 	const hasLive = Object.hasOwn(options, "live");
@@ -1847,6 +1911,12 @@ async function writeSessionStateUnlocked(
 		source: options.source ?? "coordinator",
 		live: hasLive ? (options.live ?? null) : (previous?.live ?? null),
 		reason: options.reason ?? null,
+		...(typeof existing?.last_activity_at === "string" ? { last_activity_at: existing.last_activity_at } : {}),
+		...(existing?.activity && typeof existing.activity === "object" ? { activity: existing.activity } : {}),
+		...(Array.isArray(existing?.active_tools) ? { active_tools: existing.active_tools } : {}),
+		...(existing?.active_tool_calls && typeof existing.active_tool_calls === "object"
+			? { active_tool_calls: existing.active_tool_calls }
+			: {}),
 	};
 	await writeJsonFile(sessionStateFile(namespaceDir, sessionId), payload);
 	if (
@@ -1874,108 +1944,8 @@ async function writeSessionStateUnlocked(
 	return payload;
 }
 
-interface SessionStateLockOwner {
-	pid: number;
-	start_time: string;
-	token: string;
-}
-
-function processStartTime(pid: number): string | null {
-	return readLinuxProcStartTimeSync(pid);
-}
-
-function validLockOwner(value: unknown): value is SessionStateLockOwner {
-	if (!value || typeof value !== "object") return false;
-	const owner = value as Partial<SessionStateLockOwner>;
-	return (
-		typeof owner.pid === "number" &&
-		Number.isSafeInteger(owner.pid) &&
-		owner.pid > 0 &&
-		typeof owner.start_time === "string" &&
-		typeof owner.token === "string" &&
-		owner.token.length > 0
-	);
-}
-
-function lockOwnerIsAlive(value: unknown): boolean {
-	if (!validLockOwner(value)) return false;
-	const owner = value;
-	try {
-		process.kill(owner.pid, 0);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ESRCH") return false;
-		return true;
-	}
-	const currentStartTime = processStartTime(owner.pid);
-	return currentStartTime === null || currentStartTime === owner.start_time;
-}
-
-async function reclaimStaleSessionStateLock(lockFile: string): Promise<void> {
-	let raw: string;
-	try {
-		raw = await fs.readFile(lockFile, "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
-	let owner: unknown;
-	try {
-		owner = JSON.parse(raw);
-	} catch {
-		owner = null;
-	}
-	if (!validLockOwner(owner)) {
-		const stat = await fs.stat(lockFile);
-		if (Date.now() - stat.mtimeMs < 30_000) return;
-	} else if (lockOwnerIsAlive(owner)) return;
-	try {
-		if ((await fs.readFile(lockFile, "utf8")) === raw) await fs.rm(lockFile);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-	}
-}
-
 async function withSessionStateLock<T>(stateFile: string, operation: () => Promise<T>): Promise<T> {
-	const lockFile = `${stateFile}.lock`;
-	const owner: SessionStateLockOwner = {
-		pid: process.pid,
-		start_time: processStartTime(process.pid) ?? "unknown",
-		token: randomUUID(),
-	};
-	await ensureDir(path.dirname(stateFile));
-	for (let attempt = 0; attempt < 12_000; attempt++) {
-		let handle: fs.FileHandle | undefined;
-		try {
-			handle = await fs.open(lockFile, "wx");
-			try {
-				await handle.writeFile(JSON.stringify(owner));
-			} catch (error) {
-				await handle.close().catch(() => undefined);
-				handle = undefined;
-				await fs.rm(lockFile, { force: true }).catch(() => undefined);
-				throw error;
-			}
-			const outcome = await operation().then(
-				value => ({ ok: true as const, value }),
-				error => ({ ok: false as const, error }),
-			);
-			await handle.close();
-			try {
-				if ((await fs.readFile(lockFile, "utf8")) === JSON.stringify(owner)) await fs.rm(lockFile);
-			} catch (error) {
-				if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-			}
-			if (!outcome.ok) throw outcome.error;
-			return outcome.value;
-		} catch (error) {
-			if (handle) throw error;
-			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw new Error("coordinator_state_unreadable");
-
-			await reclaimStaleSessionStateLock(lockFile);
-			await Bun.sleep(5);
-		}
-	}
-	throw new Error("coordinator_state_unreadable");
+	return await withFileLock(stateFile, operation, { staleMs: 30_000, retries: 12_000, retryDelayMs: 5 });
 }
 
 async function writeSessionState(
@@ -3191,7 +3161,15 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 				...(timeoutMs === undefined ? {} : { timeoutMs }),
 			});
 		} catch (error) {
-			requestError = toCoordinatorBrokerError("request", error);
+			const mapped = toCoordinatorBrokerError("request", error);
+			if (
+				isLifecycleOperation(operation) &&
+				mapped.code === "uncertain_after_send" &&
+				mapped.details &&
+				typeof mapped.details === "object"
+			)
+				result = await client.lookupLifecycle(mapped.details as SdkSentRecord);
+			else requestError = mapped;
 		}
 		try {
 			await client.close();

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,