@gajae-code/coding-agent 0.13.1 → 0.13.2

package/src/modes/interactive-mode.ts

@@ -1345,7 +1345,11 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.editorContainer.clear();
 			this.editorContainer.addChild(this.editor);
 		}
+		// Re-mounting after a cancelled action must invalidate the editor so the
+		// inline prompt suggestion is rendered again on the restored composer.
+		this.editor.invalidate();
 		this.ui.setFocus(this.editor);
+		this.ui.requestRender();
 	}
 
 	#createPetWidget(editor: CustomEditor): GajaePetWidget {

package/src/sdk/broker/process-incarnation.ts

@@ -40,7 +40,12 @@ export interface ProcessIncarnationOptions {
 
 function runProcessIncarnationCommand(command: string, args: readonly string[]): ProcessIncarnationCommandResult {
 	try {
-		const result = Bun.spawnSync([command, ...args], { stdin: "ignore", stdout: "pipe", stderr: "ignore" });
+		const result = Bun.spawnSync([command, ...args], {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "ignore",
+			windowsHide: true,
+		});
 		return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout).toString("utf8") };
 	} catch {
 		return undefined;

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -105,8 +105,10 @@ export const NOTIFICATION_PROTOCOL_VERSION = 3;
  * settles non-forum close responses. Generation 62 rejects replay-gap
  * authority claims that do not match the requested cursor, answer bounds,
  * and retained replay suffix.
+ * Generation 63 contains transient steady-heartbeat state and ownership-lock
+ * read failures and cleans every staged sidecar before retrying (#4200).
  */
-export const DAEMON_GENERATION = 62;
+export const DAEMON_GENERATION = 63;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 5

package/src/sdk/bus/telegram-daemon.ts

@@ -1419,38 +1419,38 @@ export async function renewOwnerHeartbeatSidecar(input: {
 		logger.warn(`notifications: heartbeat sidecar staging failed: ${sanitizeDiagnostic(String(error))}`);
 		return "publish_failed";
 	}
-	const lock = await readOwnershipLock(fsImpl, paths.lock);
-	if (!ownershipLockMatchesState(lock, state)) {
-		await fsImpl.unlink(tmp).catch(() => undefined);
-		return "not_owner";
-	}
-	for (let attempt = 1; ; attempt++) {
-		// Revalidate the exact lock after the temporary sidecar exists — and again
-		// before every retry — so a stale writer cannot publish after ownership
-		// moved during its write or its backoff.
-		const finalLock = await readOwnershipLock(fsImpl, paths.lock);
-		if (!ownershipLockMatchesState(finalLock, state)) {
-			await fsImpl.unlink(tmp).catch(() => undefined);
-			return "not_owner";
-		}
-		try {
-			await fsImpl.rename(tmp, paths.heartbeat);
-			return "renewed";
-		} catch (error) {
-			// Windows: a transient external lock on the destination (antivirus,
-			// indexer) surfaces as EPERM on rename and used to escape as an
-			// uncaught exception that killed the whole daemon (#4200). Retry a
-			// bounded number of times under the lock fence, then keep the daemon
-			// alive and let the next heartbeat cycle publish.
-			if (attempt >= HEARTBEAT_SIDECAR_PUBLISH_ATTEMPTS || !isTransientSidecarPublishError(error)) {
-				await fsImpl.unlink(tmp).catch(() => undefined);
-				logger.warn(
-					`notifications: heartbeat sidecar publication failed after ${attempt} attempt(s): ${sanitizeDiagnostic(String(error))}`,
-				);
-				return "publish_failed";
+	try {
+		const lock = await readOwnershipLock(fsImpl, paths.lock);
+		if (!ownershipLockMatchesState(lock, state)) return "not_owner";
+		for (let attempt = 1; ; attempt++) {
+			// Revalidate the exact lock after the temporary sidecar exists — and again
+			// before every retry — so a stale writer cannot publish after ownership
+			// moved during its write or its backoff.
+			const finalLock = await readOwnershipLock(fsImpl, paths.lock);
+			if (!ownershipLockMatchesState(finalLock, state)) return "not_owner";
+			try {
+				await fsImpl.rename(tmp, paths.heartbeat);
+				return "renewed";
+			} catch (error) {
+				// Windows: a transient external lock on the destination (antivirus,
+				// indexer) surfaces as EPERM on rename and used to escape as an
+				// uncaught exception that killed the whole daemon (#4200). Retry a
+				// bounded number of times under the lock fence, then keep the daemon
+				// alive and let the next heartbeat cycle publish.
+				if (attempt >= HEARTBEAT_SIDECAR_PUBLISH_ATTEMPTS || !isTransientSidecarPublishError(error)) {
+					logger.warn(
+						`notifications: heartbeat sidecar publication failed after ${attempt} attempt(s): ${sanitizeDiagnostic(String(error))}`,
+					);
+					return "publish_failed";
+				}
+				await Bun.sleep(HEARTBEAT_SIDECAR_PUBLISH_BACKOFF_MS * attempt);
 			}
-			await Bun.sleep(HEARTBEAT_SIDECAR_PUBLISH_BACKOFF_MS * attempt);
 		}
+	} finally {
+		// A thrown state or ownership-lock read after the staging write must not
+		// leak the live-PID staging file. After a successful rename the staging
+		// path no longer exists and this unlink is a no-op (#4200).
+		await fsImpl.unlink(tmp).catch(() => undefined);
 	}
 }
 
@@ -12490,19 +12490,27 @@ export class TelegramNotificationDaemon {
 			let idleSince = this.runtime.now();
 			while (this.running) {
 				if (await this.controlStopRequested()) break;
-				if (
-					(await renewOwnerHeartbeatSidecar({
-						settings: this.opts.settings,
-						ownerId: this.opts.ownerId,
-						acquisitionId: this.opts.ownerId,
-						fs: this.fsImpl,
-						now: this.opts.now,
-						pid: this.opts.pid ?? process.pid,
-						pidIncarnation: this.opts.pidIncarnation,
-						attachedEndpoints: this.attachedEndpointCount(),
-					})) === "not_owner"
-				)
-					break;
+				// Transient Windows state/lock read failures must not terminate the
+				// notification daemon. Only a proven ownership mismatch stops it.
+				let ownerHeld = true;
+				try {
+					ownerHeld =
+						(await renewOwnerHeartbeatSidecar({
+							settings: this.opts.settings,
+							ownerId: this.opts.ownerId,
+							acquisitionId: this.opts.ownerId,
+							fs: this.fsImpl,
+							now: this.opts.now,
+							pid: this.opts.pid ?? process.pid,
+							pidIncarnation: this.opts.pidIncarnation,
+							attachedEndpoints: this.attachedEndpointCount(),
+						})) !== "not_owner";
+				} catch (error) {
+					logger.warn(
+						`notifications: ownership heartbeat renewal threw; continuing: ${sanitizeDiagnostic(String(error))}`,
+					);
+				}
+				if (!ownerHeld) break;
 				await this.runScan();
 				if (await this.controlStopRequested()) break;
 				const idleElapsed = this.runtime.now() - idleSince >= (this.opts.idleTimeoutMs ?? 60_000);

package/src/session/internal/managed-session-storage.ts

@@ -9,6 +9,7 @@ import type {
 	RecoveryFsIdentity,
 	RecoveryFsRoot,
 } from "@gajae-code/natives";
+import { isEnoent, logger } from "@gajae-code/utils";
 import type { SessionStorageRangeSnapshot, SessionStorageStat } from "../session-storage";
 import {
 	classifyNativePublishOutcome,
@@ -25,8 +26,10 @@ type NativeManagedSessionStorage = Pick<
 	| "exactReplacePath"
 	| "exactUnlink"
 	| "linkNoReplacePath"
+	| "linkNoReplacePathAsync"
 	| "openRecoveryFsRoot"
 	| "renameNoReplacePath"
+	| "renameNoReplacePathAsync"
 	| "repairOwnerOnlyPathSecurityExpected"
 	| "snapshotDirectoryTree"
 	| "verifyOwnerOnlyFdSecurity"
@@ -497,6 +500,22 @@ const SCRUBBED_REMNANT_PREFIXES = [
 /** In-flight protocol steps complete in milliseconds; anything older is abandoned. */
 const SCRUBBED_REMNANT_MIN_AGE_MS = 15 * 60 * 1000;
 
+/** Minimum interval between best-effort remnant reaps of one bound store directory. */
+const SCRUBBED_REMNANT_REAP_INTERVAL_MS = 60_000;
+
+export interface ScrubbedProtocolRemnantReapResult {
+	readonly reaped: number;
+	readonly failures: number;
+}
+
+function reportScrubbedProtocolRemnantReap(reaped: number, failures: number): ScrubbedProtocolRemnantReapResult {
+	if (failures > 0)
+		logger.warn("Managed session remnant reaping completed with failures", {
+			failureCount: failures,
+			reapedCount: reaped,
+		});
+	return { reaped, failures };
+}
 /**
  * Best-effort removal of scrubbed write-protocol remnants from one managed
  * directory. Only zero-length, single-link, non-symlink regular files whose
@@ -535,6 +554,48 @@ export function reapScrubbedProtocolRemnantsSync(
 	return reaped;
 }
 
+/** Number of candidate remnants inspected between event-loop yields. */
+const SCRUBBED_REMNANT_REAP_BATCH_SIZE = 256;
+
+/**
+ * Async twin of {@link reapScrubbedProtocolRemnantsSync} with the same safety
+ * filters (terminal remnant prefix, zero-length, single-link, non-symlink,
+ * older than the age gate), yielding between bounded batches. Long-lived
+ * processes reap per-session descendant directories through this path so a
+ * legacy oversized directory cannot starve timers or sibling subagents while
+ * it is being drained (issue #4394).
+ */
+export async function reapScrubbedProtocolRemnants(
+	directory: string,
+	minAgeMs: number = SCRUBBED_REMNANT_MIN_AGE_MS,
+): Promise<ScrubbedProtocolRemnantReapResult> {
+	let names: string[];
+	try {
+		names = await fsp.readdir(directory);
+	} catch (error) {
+		return reportScrubbedProtocolRemnantReap(0, isEnoent(error) ? 0 : 1);
+	}
+	const cutoff = Date.now() - minAgeMs;
+	let reaped = 0;
+	let failures = 0;
+	let scanned = 0;
+	for (const name of names) {
+		if (!SCRUBBED_REMNANT_PREFIXES.some(prefix => name.startsWith(prefix))) continue;
+		if (++scanned % SCRUBBED_REMNANT_REAP_BATCH_SIZE === 0) await Bun.sleep(0);
+		const pathname = path.join(directory, name);
+		try {
+			const named = await fsp.lstat(pathname);
+			if (!named.isFile() || named.isSymbolicLink() || named.nlink !== 1 || named.size !== 0) continue;
+			if (named.mtimeMs > cutoff) continue;
+			await fsp.unlink(pathname);
+			reaped += 1;
+		} catch (error) {
+			if (!isEnoent(error)) failures += 1;
+		}
+	}
+	return reportScrubbedProtocolRemnantReap(reaped, failures);
+}
+
 const ACL_FAILURE_CODES = new Set(["acl_denied", "acl_io_error", "acl_present", "acl_malformed", "acl_unknown"]);
 const ACL_CLEAR_EVIDENCE = new Set(["cleared", "already_absent", "unsupported", "not_run"]);
 const GENERAL_FAILURE_CODES = new Set([
@@ -895,6 +956,8 @@ export class ManagedSessionDescendantStore {
 	#ownsAuthority = false;
 	#closed = false;
 	#reconcilingReplacementCleanup = false;
+	#remnantReapInFlight = false;
+	#lastRemnantReapAttempt = 0;
 	readonly #authorityBaseDir: string;
 	/** Logical profile root inherited by nested managed session destinations. */
 	readonly #profileAgentDir: string;
@@ -1340,6 +1403,30 @@ export class ManagedSessionDescendantStore {
 		this.#assertBound();
 		this.#reconcileReplacementCleanupReceipts();
 		this.#assertBound();
+		this.#scheduleRemnantReap();
+	}
+
+	/**
+	 * Best-effort asynchronous reaping of scrubbed write-protocol remnants in
+	 * this store's bound directory. Replacements leak zero-byte remnants on
+	 * platforms without retained authority (macOS), and scope-resolution reaping
+	 * never visits per-session descendant directories, so unbounded remnant
+	 * growth there degraded every namespace mutation and let one publication
+	 * stall the whole process (issue #4394). Reaping is throttled, serialized
+	 * per store, and never fails the triggering mutation.
+	 */
+	#scheduleRemnantReap(): void {
+		const now = Date.now();
+		if (this.#remnantReapInFlight || now - this.#lastRemnantReapAttempt < SCRUBBED_REMNANT_REAP_INTERVAL_MS) return;
+		this.#lastRemnantReapAttempt = now;
+		this.#remnantReapInFlight = true;
+		void reapScrubbedProtocolRemnants(this.#baseDir)
+			.catch((error: unknown) => {
+				logger.warn("Managed session remnant reaping failed", { error: String(error) });
+			})
+			.finally(() => {
+				this.#remnantReapInFlight = false;
+			});
 	}
 
 	ensureDirectory(relativePath = ""): ManagedDirectoryRoot {
@@ -2255,6 +2342,17 @@ function fsyncDirectory(pathname: string): void {
 	}
 }
 
+/** Async twin of {@link fsyncDirectory} for the off-loop publication path. */
+async function fsyncDirectoryAsync(pathname: string): Promise<void> {
+	if (!shouldFsyncManagedDirectory()) return;
+	const handle = await fsp.open(pathname, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY);
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+
 function bootId(): string | undefined {
 	try {
 		return fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
@@ -2536,7 +2634,7 @@ export async function publishManagedFileNoReplace(
 	const parent = path.dirname(destination);
 	ensureManagedDirectory(parent, root, policy);
 	const staging = path.join(parent, `.${path.basename(destination)}.${randomUUID()}.staging`);
-	let fd: number | undefined;
+	let handle: fsp.FileHandle | undefined;
 	let stagingIdentity: { dev: bigint; ino: bigint } | undefined;
 	let failure: unknown;
 	let outcome: NativePublishOutcome | undefined;
@@ -2545,36 +2643,47 @@ export async function publishManagedFileNoReplace(
 
 	try {
 		assertOwned?.();
-		fd = fs.openSync(
+		// The whole staging + publication chain is awaited off the resident event
+		// loop: FileHandle operations run on the libuv pool and the no-replace
+		// namespace publication crosses the async native boundary. A rename that
+		// stalls in the kernel — e.g. into an oversized APFS directory namespace,
+		// issue #4394 — blocks one pool thread instead of freezing the process:
+		// await timeouts, sibling subagents, and watchdogs keep running, and a
+		// hung publication degrades to one unresolved receipt.
+		handle = await fsp.open(
 			staging,
 			fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW,
 			0o600,
 		);
-		secureFileDescriptor(staging, fd, "apply");
+		secureFileDescriptor(staging, handle.fd, "apply");
 		let offset = 0;
-		while (offset < bytes.byteLength) offset += fs.writeSync(fd, bytes, offset, bytes.byteLength - offset);
-		fs.fsyncSync(fd);
-		secureFileDescriptor(staging, fd, "verify");
-		const staged = fs.fstatSync(fd, { bigint: true });
+		while (offset < bytes.byteLength) {
+			const { bytesWritten } = await handle.write(bytes, offset, bytes.byteLength - offset);
+			if (bytesWritten <= 0) throw new Error("managed_publish_failed");
+			offset += bytesWritten;
+		}
+		await handle.sync();
+		secureFileDescriptor(staging, handle.fd, "verify");
+		const staged = await handle.stat({ bigint: true });
 		stagingIdentity = { dev: staged.dev, ino: staged.ino };
 		assertOwned?.();
 
 		renameAttempted = true;
-		outcome = classifyNativePublishOutcome(nativeSessionStorage().renameNoReplacePath(staging, destination));
+		outcome = classifyNativePublishOutcome(
+			await nativeSessionStorage().renameNoReplacePathAsync(staging, destination),
+		);
 		if (renameFlagsUnsupported(outcome)) {
-			// linkat publishes the destination without consuming the staging name, so the
-			// secured staging descriptor stays authoritative across publication exactly as
-			// it does across a rename. The staging link is removed in the finally block
-			// below, after that descriptor is closed: unlinking a still-open name on NFS
-			// silly-renames it instead of removing it, which would leave a second link on
-			// the published inode.
-			outcome = classifyNativePublishOutcome(nativeSessionStorage().linkNoReplacePath(staging, destination));
+			// See publishManagedFileNoReplaceSync: the staging link outlives this
+			// publication and is removed only after the secured descriptor is closed.
+			outcome = classifyNativePublishOutcome(
+				await nativeSessionStorage().linkNoReplacePathAsync(staging, destination),
+			);
 			linkPublished = outcome.ok;
 		}
 
 		if (!outcome.ok) throw publishFailure(outcome);
 
-		const named = fs.lstatSync(destination, { bigint: true });
+		const named = await fsp.lstat(destination, { bigint: true });
 		if (
 			!named.isFile() ||
 			named.isSymbolicLink() ||
@@ -2583,15 +2692,21 @@ export async function publishManagedFileNoReplace(
 		) {
 			throw new Error("destination_identity_changed");
 		}
-		secureFileDescriptor(destination, fd, "verify");
-		fs.closeSync(fd);
-		fd = undefined;
+		secureFileDescriptor(destination, handle.fd, "verify");
+		await handle.close();
+		handle = undefined;
 
-		fsyncDirectory(parent);
+		await fsyncDirectoryAsync(parent);
 	} catch (error) {
 		failure = error;
 	} finally {
-		if (fd !== undefined) fs.closeSync(fd);
+		if (handle !== undefined) {
+			try {
+				await handle.close();
+			} catch (error) {
+				failure ??= error;
+			}
+		}
 
 		if (stagingIdentity && (linkPublished || !renameAttempted || (outcome && mayCleanCurrentStaging(outcome)))) {
 			await fsp

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/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++) {
@@ -2036,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 {
@@ -2113,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);
 		}
 	}