@gajae-code/coding-agent 0.13.0 → 0.13.1

package/src/session/session-storage.ts

@@ -748,14 +748,47 @@ function fsyncDirectorySync(pathname: string): void {
 
 /** Best-effort identity-checked removal of one of our own staged temp names. */
 function unlinkOwnedStagedSync(stagingPath: string, expected: { dev: bigint; ino: bigint }): void {
+	let fd: number | undefined;
 	try {
 		const named = fs.lstatSync(stagingPath, { bigint: true });
 		if (!named.isFile() || named.isSymbolicLink() || named.dev !== expected.dev || named.ino !== expected.ino) return;
-		const sha256 = createHash("sha256").update(fs.readFileSync(stagingPath)).digest("hex");
-		exactRemoveSessionStorageLockPath(stagingPath, named, sha256, named.nlink > 1n);
+		fd = fs.openSync(stagingPath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+		const opened = fs.fstatSync(fd, { bigint: true });
+		if (
+			!opened.isFile() ||
+			opened.dev !== named.dev ||
+			opened.ino !== named.ino ||
+			opened.nlink !== named.nlink ||
+			opened.size !== named.size ||
+			opened.mtimeNs !== named.mtimeNs ||
+			opened.ctimeNs !== named.ctimeNs
+		)
+			return;
+		const hash = createHash("sha256");
+		const buffer = Buffer.allocUnsafe(64 * 1024);
+		let offset = 0;
+		while (offset < Number(opened.size)) {
+			const length = Math.min(buffer.byteLength, Number(opened.size) - offset);
+			const count = fs.readSync(fd, buffer, 0, length, offset);
+			if (count === 0) return;
+			hash.update(buffer.subarray(0, count));
+			offset += count;
+		}
+		const after = fs.fstatSync(fd, { bigint: true });
+		if (
+			after.dev !== opened.dev ||
+			after.ino !== opened.ino ||
+			after.nlink !== opened.nlink ||
+			after.size !== opened.size ||
+			after.mtimeNs !== opened.mtimeNs ||
+			after.ctimeNs !== opened.ctimeNs
+		)
+			return;
+		exactRemoveSessionStorageLockPath(stagingPath, after, hash.digest("hex"), after.nlink > 1n);
 	} catch {
 		// ENOENT means the name was already consumed or removed; cleanup is best-effort.
-		return;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
 	}
 }
 
@@ -1601,16 +1634,16 @@ function parseSessionStorageLockOwner(bytes: Buffer): SessionStorageLockOwner |
 	}
 }
 
-function exactRemoveSessionStorageLockPath(
+function exactRemoveSessionStorageLockPathResult(
 	lockPath: string,
 	expected: fs.BigIntStats,
 	sha256: string,
 	allowHardLink = false,
-): boolean {
+): native.NativeExactUnlinkResult {
 	try {
 		const parent = fs.lstatSync(path.dirname(lockPath), { bigint: true });
-		if (!parent.isDirectory() || parent.isSymbolicLink()) return false;
-		const result = nativeSessionStorage().exactUnlink(lockPath, {
+		if (!parent.isDirectory() || parent.isSymbolicLink()) return { ok: false, code: "parent_mismatch" };
+		return nativeSessionStorage().exactUnlink(lockPath, {
 			dev: expected.dev,
 			ino: expected.ino,
 			nlink: expected.nlink,
@@ -1622,12 +1655,27 @@ function exactRemoveSessionStorageLockPath(
 			quarantineName: `${path.basename(lockPath)}.reap-${randomUUID()}`,
 			allowHardLink,
 		});
-		return result.ok || (result.code === "cleanup_pending" && typeof result.detachedPath === "string");
 	} catch {
-		return false;
+		return { ok: false, code: "native_failure" };
 	}
 }
 
+function exactRemoveSessionStorageLockPath(
+	lockPath: string,
+	expected: fs.BigIntStats,
+	sha256: string,
+	allowHardLink = false,
+): boolean {
+	const result = exactRemoveSessionStorageLockPathResult(lockPath, expected, sha256, allowHardLink);
+	return (
+		result.ok ||
+		(result.code === "cleanup_pending" &&
+			result.payloadDurable === true &&
+			!result.retainedSuccessorPath &&
+			!result.retainedUnknownPath)
+	);
+}
+
 function exactRemoveOwnedSessionStorageLockPath(
 	lockPath: string,
 	expected: Pick<fs.BigIntStats, "dev" | "ino">,
@@ -1836,7 +1884,17 @@ export class FileSessionStorage implements SessionStorage {
 				return {
 					releaseSync: () => {
 						if (released) return;
-						if (!exactRemoveSessionStorageLockPath(lockPath, expected, ownerDigest!)) {
+						const removal = exactRemoveSessionStorageLockPathResult(lockPath, expected, ownerDigest!);
+						if (!removal.ok) {
+							if (
+								removal.code === "cleanup_pending" &&
+								removal.payloadDurable === true &&
+								!removal.retainedSuccessorPath &&
+								!removal.retainedUnknownPath
+							) {
+								released = true;
+								return;
+							}
 							try {
 								const current = fs.lstatSync(lockPath, { bigint: true });
 								if (current.dev === expected.dev && current.ino === expected.ino) {

package/src/slash-commands/helpers/fast-status-report.ts

@@ -1,4 +1,4 @@
-import type { Model } from "@gajae-code/ai/core";
+import { type Model, modelSupportsServiceTier, modelsAreEqual } from "@gajae-code/ai/core";
 
 /**
  * A single line in the `/fast status` report: a labelled model and whether fast
@@ -55,7 +55,7 @@ export function formatFastStatusReport(args: FormatFastStatusReportArgs): string
 export interface FastStatusSessionLike {
 	readonly model?: Model;
 	/** Fast predicate against the main session tier (current model + `modelRoles`). */
-	isFastForProvider(provider?: string): boolean;
+	isFastForProvider(provider?: string, supportsServiceTier?: boolean): boolean;
 	/**
 	 * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
 	 * Used for the current-model row so it matches what the next request does.
@@ -63,8 +63,13 @@ export interface FastStatusSessionLike {
 	 */
 	isFastModeActive?(): boolean;
 	/** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
-	isFastForSubagentProvider(provider?: string): boolean;
+	isFastForSubagentProvider(provider?: string, supportsServiceTier?: boolean): boolean;
 	resolveRoleModelWithThinking(role: string): { model?: Model };
+	/** Runtime fallback position for the configured DEFAULT chain. */
+	getDefaultFallbackRuntimeState?(): {
+		chain: { entries: readonly string[] };
+		controller: { activeIndex: number };
+	};
 }
 
 /** A role to enumerate in the report, with the tier source its subagent runs under. */
@@ -106,15 +111,26 @@ export function buildFastStatusReport(args: BuildFastStatusReportArgs): string {
 	// on pure intent. Fall back to intent when a fake omits `isFastModeActive`.
 	const currentFast = session.isFastModeActive
 		? session.isFastModeActive()
-		: session.isFastForProvider(session.model?.provider);
+		: session.isFastForProvider(session.model?.provider, modelSupportsServiceTier(session.model));
 	const rows: FastStatusRow[] = [{ label: "현재 모델", model: session.model, fast: currentFast }];
 	for (const target of roleTargets) {
 		const resolved = session.resolveRoleModelWithThinking(target.id);
-		if (resolved.model) {
+		const fallbackState = target.id === "default" ? session.getDefaultFallbackRuntimeState?.() : undefined;
+		const activeDefaultFallback =
+			fallbackState !== undefined &&
+			fallbackState.chain.entries.length > 1 &&
+			fallbackState.controller.activeIndex > 0 &&
+			fallbackState.controller.activeIndex < fallbackState.chain.entries.length;
+		const rowModel = activeDefaultFallback && session.model ? session.model : resolved.model;
+		if (rowModel) {
+			const supportsServiceTier = modelSupportsServiceTier(rowModel);
+			const isCurrentModel = session.model !== undefined && modelsAreEqual(session.model, rowModel);
 			const fast = target.isSubagentRole
-				? session.isFastForSubagentProvider(resolved.model.provider)
-				: session.isFastForProvider(resolved.model.provider);
-			rows.push({ label: target.label, model: resolved.model, fast });
+				? session.isFastForSubagentProvider(rowModel.provider, supportsServiceTier)
+				: isCurrentModel
+					? currentFast
+					: session.isFastForProvider(rowModel.provider, supportsServiceTier);
+			rows.push({ label: target.label, model: rowModel, fast });
 		}
 	}
 	return formatFastStatusReport({ rows, iconFast, formatInactive });

package/src/task/executor.ts

@@ -15,7 +15,14 @@ import type {
 } from "@gajae-code/agent-core";
 import { recordHandoff, resolveTelemetry } from "@gajae-code/agent-core";
 import { estimateMessageTokensHeuristic } from "@gajae-code/agent-core/compaction";
-import type { AssistantMessage, Message, Model, ServiceTier } from "@gajae-code/ai/core";
+import {
+	type AssistantMessage,
+	isFastModeEffectiveForProvider,
+	type Message,
+	type Model,
+	modelSupportsServiceTier,
+	type ServiceTier,
+} from "@gajae-code/ai/core";
 import { type JsonSchemaValidationIssue, validateJsonSchemaValue } from "@gajae-code/ai/utils/schema";
 import { logger, prompt, untilAborted } from "@gajae-code/utils";
 import { AsyncJobManager } from "../async";
@@ -248,14 +255,11 @@ export interface ExecutorOptions {
 	/** Parent session's registry; shared by child sessions for IRC routing and roster visibility. */
 	agentRegistry?: AgentRegistry;
 	/**
-	 * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
-	 * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the
-	 * live value (not the stale settings snapshot) lets a runtime `/fast on` reach
-	 * subagents, and a main-model fast-mode auto-disable does not clobber it.
+	 * Parent service-tier intent captured when the child is spawned. Used when
+	 * `task.serviceTier === "inherit"` so request serialization and reporting use
+	 * the same immutable child settings snapshot.
 	 */
 	inheritedServiceTier?: ServiceTier;
-	/** Resolve whether the effective subagent tier grants fast mode for the selected provider. */
-	isFastForSubagentProvider?: (provider?: string) => boolean;
 	/** Override local:// protocol options so subagent shares parent's local:// root */
 	localProtocolOptions?: LocalProtocolOptions;
 	/**
@@ -865,6 +869,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const settings = options.settings ?? Settings.isolated();
 	const subagentSettings = createSubagentSettings(settings, options.inheritedServiceTier);
+	const configuredSubagentServiceTier = subagentSettings.get("serviceTier");
+	const subagentServiceTier = configuredSubagentServiceTier === "none" ? undefined : configuredSubagentServiceTier;
+	const isFastForModel = (candidate: Model | undefined): boolean =>
+		candidate !== undefined &&
+		isFastModeEffectiveForProvider(subagentServiceTier, candidate.provider, modelSupportsServiceTier(candidate));
 	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
 	const maxRuntimeMs = Math.max(0, Math.trunc(Number(settings.get("task.maxRuntimeMs") ?? 0) || 0));
 	const parentDepth = options.taskDepth ?? 0;
@@ -1533,7 +1542,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				resolvedModelString = formatModelString(model);
 				activeProviderModelString = resolvedModelString;
 			}
-			progress.fastMode = model ? (options.isFastForSubagentProvider?.(model.provider) ?? false) : false;
+			progress.fastMode = isFastForModel(model);
 			if (authFallbackUsed && model && requestedModel) {
 				modelSubstitutionWarning = {
 					requested: formatModelString(requestedModel),
@@ -1954,6 +1963,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 				if (event.type === "model_fallback_switched") {
 					activeProviderModelString = event.to;
+					progress.fastMode = isFastForModel(session.model);
+					AsyncJobManager.instance()?.updateSubagentModel?.(options.subagentId ?? id, {
+						requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
+						effectiveModel: event.to,
+						modelFellBack: true,
+						fastMode: progress.fastMode,
+					});
+					scheduleProgress(true);
 					forwardSubagentEvent(event);
 					return;
 				}

package/src/task/index.ts

@@ -2027,7 +2027,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						agentRegistry: this.session.agentRegistry,
 						settings: this.session.settings,
 						inheritedServiceTier: this.session.serviceTier,
-						isFastForSubagentProvider: provider => this.session.isFastForSubagentProvider?.(provider) ?? false,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -2105,7 +2104,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						agentRegistry: this.session.agentRegistry,
 						settings: this.session.settings,
 						inheritedServiceTier: this.session.serviceTier,
-						isFastForSubagentProvider: provider => this.session.isFastForSubagentProvider?.(provider) ?? false,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,

package/src/tools/index.ts

@@ -282,7 +282,7 @@ export interface ToolSession {
 	/** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
 	serviceTier?: ServiceTier;
 	/** Whether the effective subagent tier grants fast mode for a resolved provider. */
-	isFastForSubagentProvider?: (provider?: string) => boolean;
+	isFastForSubagentProvider?: (provider?: string, supportsServiceTier?: boolean) => boolean;
 	/** Plan mode state (if active) */
 	getPlanModeState?: () => PlanModeState | undefined;
 	/** Goal mode state (if active or paused) */

package/src/tools/read.ts

@@ -1447,7 +1447,18 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly name = "read";
 	readonly label = "Read";
 	readonly loadMode = "essential";
-	readonly description: string;
+	get description(): string {
+		const displayMode = resolveFileDisplayMode(this.session);
+		return prompt.render(readDescription, {
+			DEFAULT_LIMIT: String(this.#defaultLimit),
+			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
+			TRUNCATION_DEFAULT: String(this.session.settings.get("read.truncation") ?? "last"),
+			RECEIPT_LINES: String(this.session.settings.get("read.receiptBudgetLines")),
+			RECEIPT_KIB: String(this.session.settings.get("read.receiptBudgetBytes")),
+			IS_HL_MODE: displayMode.hashLines,
+			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
+		});
+	}
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;
 	readonly strict = true;
@@ -1457,21 +1468,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly #defaultLimit: number;
 
 	constructor(private readonly session: ToolSession) {
-		const displayMode = resolveFileDisplayMode(session);
 		this.#autoResizeImages = session.settings.get("images.autoResize");
 		this.#defaultLimit = Math.max(
 			1,
 			Math.min(session.settings.get("read.defaultLimit") ?? DEFAULT_MAX_LINES, DEFAULT_MAX_LINES),
 		);
-		this.description = prompt.render(readDescription, {
-			DEFAULT_LIMIT: String(this.#defaultLimit),
-			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
-			TRUNCATION_DEFAULT: String(this.session.settings.get("read.truncation") ?? "last"),
-			RECEIPT_LINES: String(this.session.settings.get("read.receiptBudgetLines")),
-			RECEIPT_KIB: String(this.session.settings.get("read.receiptBudgetBytes")),
-			IS_HL_MODE: displayMode.hashLines,
-			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
-		});
 	}
 
 	async #resolveArchiveReadPath(readPath: string, signal?: AbortSignal): Promise<ResolvedArchiveReadPath | null> {

package/src/tools/search.ts

@@ -237,17 +237,17 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 	readonly label = "Search";
 	readonly loadMode = "discoverable";
 	readonly summary = "Search file contents using ripgrep (fast text search)";
-	readonly description: string;
-	readonly parameters = searchSchema;
-	readonly strict = true;
-
-	constructor(private readonly session: ToolSession) {
-		const displayMode = resolveFileDisplayMode(session);
-		this.description = prompt.render(searchDescription, {
+	get description(): string {
+		const displayMode = resolveFileDisplayMode(this.session);
+		return prompt.render(searchDescription, {
 			IS_HL_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
 		});
 	}
+	readonly parameters = searchSchema;
+	readonly strict = true;
+
+	constructor(private readonly session: ToolSession) {}
 
 	async execute(
 		_toolCallId: string,

package/src/utils/edit-mode.ts

@@ -2,8 +2,15 @@ import { $pickenv } from "@gajae-code/utils/env";
 
 export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
+/** Setting value for `edit.mode`: an executable mode or `auto` (model-family routing). */
+export type EditModeSetting = "auto" | EditMode;
+
+/** Fallback executable mode used when automatic routing cannot identify the model. */
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
+/** Default `edit.mode` setting value. */
+export const DEFAULT_EDIT_MODE_SETTING: EditModeSetting = "auto";
+
 const EDIT_MODE_IDS = {
 	apply_patch: "apply_patch",
 	hashline: "hashline",
@@ -14,29 +21,193 @@ const EDIT_MODE_IDS = {
 
 export const EDIT_MODES = Object.keys(EDIT_MODE_IDS) as EditMode[];
 
+export const EDIT_MODE_SETTINGS: EditModeSetting[] = ["auto", ...EDIT_MODES];
+
 export function normalizeEditMode(mode?: string | null): EditMode | undefined {
 	if (!mode) return undefined;
-	return EDIT_MODE_IDS[mode as keyof typeof EDIT_MODE_IDS];
+	return Object.hasOwn(EDIT_MODE_IDS, mode) ? EDIT_MODE_IDS[mode as keyof typeof EDIT_MODE_IDS] : undefined;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Model-family detection (automatic routing)
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type ModelEditFamily = "gpt" | "codex" | "claude" | "deepseek" | "qwen" | "minimax" | "glm" | "kimi" | "unknown";
+
+/**
+ * Built-in family → edit mode mapping used by `edit.mode: auto`.
+ *
+ * GPT/Codex models are trained on the OpenAI patch grammar; Claude, DeepSeek,
+ * and Qwen perform best with exact search/replace; MiniMax, GLM, and
+ * Kimi/Moonshot benchmark best with hash-anchored edits. Unknown models fall
+ * back to hashline, the safest fail-closed default.
+ */
+const FAMILY_EDIT_MODES: Record<Exclude<ModelEditFamily, "unknown">, EditMode> = {
+	gpt: "apply_patch",
+	codex: "apply_patch",
+	claude: "replace",
+	deepseek: "replace",
+	qwen: "replace",
+	minimax: "hashline",
+	glm: "hashline",
+	kimi: "hashline",
+};
+
+/**
+ * Detect the model family from a model ID, ignoring the provider prefix so
+ * equivalent models served through different providers route identically
+ * (`openai/gpt-5.4`, `openrouter/openai/gpt-5.4`, `company-gateway/gpt-5.4`).
+ *
+ * Matching only examines the final path segment. A direct family prefix or a
+ * known provider-qualified family name is accepted, while arbitrary token
+ * substrings return `unknown` instead of guessing.
+ */
+export function detectModelEditFamily(modelId: string | undefined): ModelEditFamily {
+	if (!modelId) return "unknown";
+	const normalized = modelId.trim().toLowerCase();
+	const segments = normalized.split("/").filter(Boolean);
+	const model = segments.at(-1) ?? normalized;
+
+	if (/^codex(?:$|[-_.\d])|^(?:gpt|(?:duo-chat|openai)-gpt)-\d+(?:[-_.][\w]+)*[-_.]codex(?:$|[-_.\d])/.test(model))
+		return "codex";
+	if (
+		/^(?:gpt-\d+(?:$|[-_.])|gpt-oss(?:$|[-_.\d])|chatgpt(?:$|[-_.]\d))|(?:^|\.)openai\.(?:gpt|chatgpt)(?:$|[-_.\d])/.test(
+			model,
+		)
+	)
+		return "gpt";
+	if (/^claude(?:$|[-_.\d])|(?:^|\.)anthropic\.claude(?:$|[-_.\d])/.test(model)) return "claude";
+	if (/^deepseek(?:$|[-_.\d])|(?:^|\.)deepseek(?:$|[-_.\d])/.test(model)) return "deepseek";
+	if (/^qwen(?:$|[-_.\d])|(?:^|\.)qwen\.qwen(?:$|[-_.\d])/.test(model)) return "qwen";
+	if (/^minimax(?:$|[-_.\d])/.test(model)) return "minimax";
+	if (/^glm(?:$|[-_.\d])/.test(model)) return "glm";
+	if (/^(?:kimi|moonshot)(?:$|[-_.\d])/.test(model)) return "kimi";
+
+	return "unknown";
 }
 
+/** Built-in mode for a detected family; `undefined` for `unknown`. */
+export function builtinEditModeForFamily(family: ModelEditFamily): EditMode | undefined {
+	if (family === "unknown") return undefined;
+	return FAMILY_EDIT_MODES[family];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Resolution
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type EditModeSource = "environment" | "model-override" | "setting" | "catalog" | "builtin-family" | "fallback";
+
+export type ResolvedEditModeDetails = {
+	mode: EditMode;
+	source: EditModeSource;
+	modelId?: string;
+	family?: ModelEditFamily;
+	matchedRule?: string;
+};
+
+/** Raw `edit.modelVariants` match: pattern plus the configured (unvalidated) value. */
+export type EditVariantMatch = {
+	pattern: string;
+	value: string;
+};
+
 export interface EditModeSettingsLike {
 	get(key: "edit.mode"): unknown;
+	/** Legacy accessor: first *valid* matching `edit.modelVariants` value. */
 	getEditVariantForModel?(model: string | undefined): EditMode | null;
+	/**
+	 * Discriminated accessor: first matching `edit.modelVariants` rule with its
+	 * raw value. Lets the resolver fail closed on invalid matched values
+	 * instead of silently falling through to another mode.
+	 */
+	matchEditVariantForModel?(model: string | undefined): EditVariantMatch | null;
 }
 
 export interface EditModeSessionLike {
 	settings: EditModeSettingsLike;
 	getActiveModelString?: () => string | undefined;
+	/**
+	 * Optional model-catalog edit recommendation; beats the built-in family
+	 * mapping when present.
+	 *
+	 * Extension point: production sessions do not wire this yet — the model
+	 * catalog does not expose an edit-protocol recommendation (`applyPatchToolType`
+	 * is the OpenAI wire representation of an already-selected `apply_patch`
+	 * mode, not a mode selector). Catalog metadata generation is deliberately
+	 * deferred until the family-based path is proven for arbitrary custom-provider
+	 * IDs; when it lands, sessions can expose this hook without a resolver change.
+	 */
+	getCatalogEditMode?: () => EditMode | undefined;
 }
 
-export function resolveEditMode(session: EditModeSessionLike): EditMode {
-	const activeModel = session.getActiveModelString?.();
-	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
-	if (modelVariant) return modelVariant;
+/**
+ * Read the forced edit mode from `GJC_EDIT_VARIANT`/`PI_EDIT_VARIANT`.
+ * The environment force is the emergency kill switch and beats every other
+ * source. Invalid values fail fast; empty and `auto` mean "not forced".
+ */
+export function resolveForcedEnvEditMode(): EditMode | undefined {
+	const raw = $pickenv("GJC_EDIT_VARIANT", "PI_EDIT_VARIANT");
+	if (!raw || raw === "auto") return undefined;
+	const mode = normalizeEditMode(raw);
+	if (!mode) {
+		throw new Error(`Invalid GJC_EDIT_VARIANT: ${raw}`);
+	}
+	return mode;
+}
+
+/**
+ * Resolve the active edit mode with provenance.
+ *
+ * Precedence:
+ * 1. `GJC_EDIT_VARIANT`/`PI_EDIT_VARIANT` environment force (invalid → throw).
+ * 2. Matching user `edit.modelVariants` rule (matched invalid → throw).
+ * 3. Explicit `edit.mode` setting when it is not `auto`.
+ * 4. Model-catalog edit recommendation, when the session exposes one.
+ * 5. Built-in model-family mapping.
+ * 6. `hashline` fallback.
+ */
+export function resolveEditModeDetails(session: EditModeSessionLike): ResolvedEditModeDetails {
+	const modelId = session.getActiveModelString?.();
+
+	const envMode = resolveForcedEnvEditMode();
+	if (envMode) return { mode: envMode, source: "environment", modelId };
+
+	const settings = session.settings;
+	if (settings.matchEditVariantForModel) {
+		const match = settings.matchEditVariantForModel(modelId);
+		if (match) {
+			const mode = normalizeEditMode(match.value);
+			if (!mode) {
+				throw new Error(
+					`Invalid edit.modelVariants value "${match.value}" for pattern "${match.pattern}" (expected one of: ${EDIT_MODES.join(", ")})`,
+				);
+			}
+			return { mode, source: "model-override", modelId, matchedRule: match.pattern };
+		}
+	} else {
+		const legacyVariant = settings.getEditVariantForModel?.(modelId);
+		if (legacyVariant) return { mode: legacyVariant, source: "model-override", modelId };
+	}
 
-	const envMode = normalizeEditMode($pickenv("GJC_EDIT_VARIANT", "PI_EDIT_VARIANT"));
-	if (envMode) return envMode;
+	const rawSetting = settings.get("edit.mode");
+	const settingValue = typeof rawSetting === "string" ? rawSetting : undefined;
+	if (settingValue && settingValue !== "auto") {
+		const settingsMode = normalizeEditMode(settingValue);
+		if (settingsMode) return { mode: settingsMode, source: "setting", modelId };
+	}
 
-	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));
-	return settingsMode ?? DEFAULT_EDIT_MODE;
+	const family = detectModelEditFamily(modelId);
+
+	const catalogMode = session.getCatalogEditMode?.();
+	if (catalogMode) return { mode: catalogMode, source: "catalog", modelId, family };
+
+	const builtinMode = builtinEditModeForFamily(family);
+	if (builtinMode) return { mode: builtinMode, source: "builtin-family", modelId, family };
+
+	return { mode: DEFAULT_EDIT_MODE, source: "fallback", modelId, family };
+}
+
+export function resolveEditMode(session: EditModeSessionLike): EditMode {
+	return resolveEditModeDetails(session).mode;
 }

package/src/web/search/providers/insane.ts

@@ -25,6 +25,7 @@ const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 20;
 const PUBLIC_ROUTE_TIMEOUT_MS = 15_000;
 const DISCOVERY_LIMIT = 8;
+const MAX_PUBLIC_ROUTE_RESPONSE_BYTES = 1024 * 1024;
 
 const USER_AGENT = "Gajae-Code insane-search safe-public-routes/1.0 (+https://github.com/Yeachan-Heo/gajae-code)";
 
@@ -146,6 +147,59 @@ function attempt(
 	return { platform, route, ok, status, bytes: new TextEncoder().encode(body).byteLength, note };
 }
 
+class ResponseTooLargeError extends Error {
+	override readonly name = "response_too_large";
+}
+
+async function cancelBody(body: ReadableStream<Uint8Array> | null): Promise<void> {
+	if (!body) return;
+	try {
+		await body.cancel();
+	} catch {
+		// Best-effort teardown; preserve the stable size-limit diagnostic.
+	}
+}
+
+async function readResponseText(response: Response): Promise<string> {
+	const contentLength = response.headers.get("content-length");
+	if (contentLength !== null) {
+		const declaredBytes = Number.parseInt(contentLength, 10);
+		if (Number.isFinite(declaredBytes) && declaredBytes > MAX_PUBLIC_ROUTE_RESPONSE_BYTES) {
+			await cancelBody(response.body);
+			throw new ResponseTooLargeError();
+		}
+	}
+
+	const reader = response.body?.getReader();
+	if (!reader) return "";
+
+	const decoder = new TextDecoder();
+	let totalBytes = 0;
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (!value || value.byteLength === 0) continue;
+
+			totalBytes += value.byteLength;
+			if (totalBytes > MAX_PUBLIC_ROUTE_RESPONSE_BYTES) {
+				try {
+					await reader.cancel();
+				} catch {
+					// Best-effort teardown; preserve the stable size-limit diagnostic.
+				}
+				throw new ResponseTooLargeError();
+			}
+			text += decoder.decode(value, { stream: true });
+		}
+		text += decoder.decode();
+		return text;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
 async function fetchText(
 	url: string,
 	signal?: AbortSignal,
@@ -158,7 +212,7 @@ async function fetchText(
 		redirect: "follow",
 		signal: withHardTimeout(signal, PUBLIC_ROUTE_TIMEOUT_MS),
 	});
-	const text = await response.text();
+	const text = await readResponseText(response);
 	return { status: response.status, text, contentType: response.headers.get("content-type") ?? "" };
 }