@gajae-code/coding-agent 0.13.0 → 0.13.2

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/builtin-registry.ts

@@ -23,7 +23,7 @@ import {
 } from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { DynamicBorder } from "../modes/components/dynamic-border";
-import { theme } from "../modes/theme/theme";
+import { getAvailableThemes, getDetectedThemeSettingsPath, setTheme, theme } from "../modes/theme/theme";
 import {
 	type ComposerSubmissionOptions,
 	canApplyComposerSubmission,
@@ -709,10 +709,48 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "theme",
-		description: "Open theme selector",
-		handleTui: (_command, runtime) => {
-			runtime.ctx.showThemeSelector();
-			runtime.ctx.editor.setText("");
+		description: "Change theme immediately, or open the theme selector without args",
+		inlineHint: "[theme]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const ctx = runtime.ctx;
+			const name = command.args?.trim();
+			if (!name) {
+				ctx.showThemeSelector();
+				ctx.editor.setText("");
+				return;
+			}
+			const available = await getAvailableThemes();
+			if (!available.includes(name)) {
+				ctx.showError(`Unknown theme "${name}". Available themes: ${available.join(", ")}`);
+				ctx.editor.setText("");
+				return;
+			}
+			if (!ctx.settings.canWriteDurableConfig()) {
+				ctx.showError(
+					"Cannot change settings while config.yml has invalid YAML syntax. Repair config.yml and reload settings.",
+				);
+				ctx.editor.setText("");
+				return;
+			}
+			try {
+				ctx.settings.set(getDetectedThemeSettingsPath(), name);
+			} catch (error) {
+				ctx.showError(error instanceof Error ? error.message : String(error));
+				ctx.editor.setText("");
+				return;
+			}
+			const result = await setTheme(name, true, { shouldApply: () => !ctx.isStopped?.() });
+			if (ctx.isStopped?.()) return;
+			ctx.statusLine.invalidate();
+			ctx.updateEditorTopBorder();
+			ctx.ui.invalidate();
+			if (result.success) {
+				ctx.showStatus(`Theme changed to ${name}`);
+			} else {
+				ctx.showError(`Failed to load theme "${name}": ${result.error}\nFell back to dark theme.`);
+			}
+			ctx.editor.setText("");
 		},
 	},
 	{

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

@@ -1900,6 +1900,9 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				file => path.basename(file.path).toLowerCase() !== "agents.md",
 			);
 			const promptTemplates = this.session.promptTemplates;
+			const parentMcpManager = this.session.getMcpManager?.();
+			// Exact-config tools-only managers belong to the top-level ACP session and cannot be reused by sub-sessions.
+			const reusableParentMcpManager = parentMcpManager?.isToolsOnly() ? undefined : parentMcpManager;
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithUniqueIds.length; i++) {
@@ -2027,7 +2030,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,
@@ -2037,7 +2039,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
-						parentMcpManager: this.session.getMcpManager?.(),
+						parentMcpManager: reusableParentMcpManager,
 						forkContextSeed,
 					});
 					return {
@@ -2105,7 +2107,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,
@@ -2115,7 +2116,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
-						parentMcpManager: this.session.getMcpManager?.(),
+						parentMcpManager: reusableParentMcpManager,
 						forkContextSeed,
 					});
 					let capturedResult = {

package/src/tools/bash.ts

@@ -862,26 +862,28 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			return { kind: "aborted" };
 		}
 
+		const threshold = Promise.withResolvers<{ kind: "running" }>();
+		const thresholdTimer = setTimeout(() => threshold.resolve({ kind: "running" }), Math.max(0, thresholdMs));
 		const waiters: Array<Promise<ManagedBashJobCompletion | { kind: "running" } | { kind: "aborted" }>> = [
 			job.completion,
-			Bun.sleep(thresholdMs).then(() => ({ kind: "running" as const })),
+			threshold.promise,
 		];
 		if (backgroundRequest) {
 			waiters.push(backgroundRequest.then(() => ({ kind: "running" as const })));
 		}
 
-		if (!signal) {
-			return await Promise.race(waiters);
+		let onAbort: (() => void) | undefined;
+		if (signal) {
+			const aborted = Promise.withResolvers<{ kind: "aborted" }>();
+			onAbort = () => aborted.resolve({ kind: "aborted" });
+			signal.addEventListener("abort", onAbort, { once: true });
+			waiters.push(aborted.promise);
 		}
-
-		const { promise: abortedPromise, resolve: resolveAborted } = Promise.withResolvers<{ kind: "aborted" }>();
-		const onAbort = () => resolveAborted({ kind: "aborted" });
-		signal.addEventListener("abort", onAbort, { once: true });
-		waiters.push(abortedPromise);
 		try {
 			return await Promise.race(waiters);
 		} finally {
-			signal.removeEventListener("abort", onAbort);
+			clearTimeout(thresholdTimer);
+			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
 		}
 	}
 

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,