@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/modes/controllers/selector-controller.ts

@@ -4,7 +4,10 @@ import {
 	type Api,
 	type AuthCredentialSelector,
 	type CredentialRemovalTarget,
+	isSqliteCorruptionError,
+	isSqliteError,
 	type Model,
+	OAuthCredentialSelectorError,
 	resolveOAuthStorageProvider,
 } from "@gajae-code/ai/core";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
@@ -106,6 +109,7 @@ import { TelegramDaemonController } from "../../sdk/bus/telegram-daemon-control"
 import { runTelegramSetup, type TelegramSetupPreflight } from "../../sdk/bus/telegram-setup";
 import { clearPersistentPinForRemovedRows } from "../../session/account-inventory";
 import type { DefaultFallbackRuntimeState } from "../../session/agent-session";
+import { CREDENTIAL_STORE_UNREADABLE_MESSAGE } from "../../session/credential-store-errors";
 import { type SessionInfo, SessionManager } from "../../session/session-manager";
 import { getTreeForInternalRead } from "../../session/session-manager-internal";
 import { FileSessionStorage } from "../../session/session-storage";
@@ -125,6 +129,12 @@ import {
 	logCredentialAutoImportFailures,
 	runExternalCredentialAutoImport,
 } from "../../setup/credential-auto-import";
+
+function credentialStoreOperationError(action: "Login" | "Logout", error: unknown): string {
+	const code = error && typeof error === "object" ? (error as { code?: unknown }).code : undefined;
+	return `${action} failed: credential store operation failed${typeof code === "string" ? ` (${code})` : ""}.`;
+}
+
 import {
 	filterAutoImportOAuthCredentials,
 	formatDiscoverySummary,
@@ -172,6 +182,7 @@ import {
 	FrictionlessOnboardingSelectorComponent,
 	type FrictionlessOnboardingStage,
 	getFrictionlessOnboardingCopy,
+	InterfaceLanguageSelectorComponent,
 } from "../components/frictionless-onboarding-selector";
 import type { PetMode } from "../components/gajae-pet-widget";
 import { HistorySearchComponent } from "../components/history-search";
@@ -216,6 +227,7 @@ import type { SessionObserverRegistry } from "../session-observer-registry";
 import { buildOAuthLoginAnchor, createOAuthUrlCopyLease } from "../shared/oauth-url-copy";
 import type { TasksAggregator } from "../tasks-aggregator";
 import type { TranscriptItemRegistry } from "../transcript-item-registry";
+import { resolveExplicitUiLanguage, type UiLanguage } from "../ui-language";
 import { acquireResumeProgressLease, type ResumeProgressLease } from "../utils/ui-helpers";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<string>([
@@ -1366,11 +1378,16 @@ export class SelectorController {
 	async #refreshOAuthProviderAuthState(): Promise<void> {
 		const oauthProviders = getOAuthProviders();
 		await Promise.all(
-			oauthProviders.map(provider =>
-				this.ctx.session.modelRegistry
-					.getApiKeyForProvider(provider.id, this.ctx.session.credentialSessionId)
-					.catch(() => undefined),
-			),
+			oauthProviders.map(async provider => {
+				try {
+					await this.ctx.session.modelRegistry.getApiKeyForProvider(
+						provider.id,
+						this.ctx.session.credentialSessionId,
+					);
+				} catch (error) {
+					if (isSqliteError(error)) throw error;
+				}
+			}),
 		);
 	}
 	/**
@@ -1469,11 +1486,57 @@ export class SelectorController {
 
 	async showFrictionlessOnboarding(): Promise<void> {
 		const agentDir = this.ctx.session.getSessionAgentDir();
+		const languagePreference = resolveExplicitUiLanguage(
+			this.ctx.settings.has("ui.language") ? this.ctx.settings.get("ui.language") : undefined,
+			process.env.GJC_UI_LANGUAGE,
+		);
+		let selectedLanguage: UiLanguage = languagePreference.language;
+		if (!languagePreference.hasPreference && this.ctx.settings.canPersistDurableConfig()) {
+			const decision = Promise.withResolvers<UiLanguage | undefined>();
+			let settled = false;
+			let unregisterStop: (() => void) | undefined;
+			const finish = (language: UiLanguage | undefined): void => {
+				if (settled) return;
+				settled = true;
+				unregisterStop?.();
+				decision.resolve(language);
+			};
+			this.showSelector(done => {
+				unregisterStop = this.ctx.onStop(() => {
+					done();
+					finish(undefined);
+				});
+				const selector = new InterfaceLanguageSelectorComponent(
+					language => {
+						done();
+						finish(language);
+					},
+					() => {
+						done();
+						finish(undefined);
+					},
+				);
+				return { component: selector, focus: selector };
+			});
+			selectedLanguage = (await decision.promise) ?? "en";
+			try {
+				await this.ctx.settings.commitAtomicBatch([{ path: "ui.language", op: "set", value: selectedLanguage }]);
+			} catch (error) {
+				this.ctx.showError(
+					error instanceof Error
+						? `${error.message}; continuing in English.`
+						: "Cannot save the interface language; continuing in English.",
+				);
+				selectedLanguage = "en";
+			}
+		} else if (!languagePreference.hasPreference) {
+			this.ctx.showError("Cannot save the interface language; continuing in English.");
+		}
 		const presence = await discoverOnboardingRootPresence();
 		// An explicit `/language` (or settings) selection outranks locale and transcript evidence.
 		const profileOptions = {
 			osLocale: Intl.DateTimeFormat().resolvedOptions().locale,
-			...(this.ctx.settings.has("ui.language") ? { preferredLanguage: this.ctx.settings.get("ui.language") } : {}),
+			preferredLanguage: selectedLanguage,
 		};
 		const initialProfile = deriveOnboardingProfile([], profileOptions);
 
@@ -2181,8 +2244,8 @@ export class SelectorController {
 			case "followUpMode":
 				this.ctx.session.setFollowUpMode(value as "all" | "one-at-a-time");
 				break;
-			case "interruptMode":
-				this.ctx.session.setInterruptMode(value as "immediate" | "wait");
+			case "toolInterruptPolicy":
+				this.ctx.session.setToolInterruptPolicy(value as "abort_tools" | "finish_tools");
 				break;
 			case "thinkingLevel":
 			case "defaultThinkingLevel":
@@ -3557,7 +3620,8 @@ export class SelectorController {
 			}
 			this.ctx.ui.requestRender();
 		} catch (error: unknown) {
-			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+			else this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
 		} finally {
 			oauthUrlCopyLease.release();
 			if (useManualInput) {
@@ -3599,7 +3663,8 @@ export class SelectorController {
 				`Successfully removed ${result.ids.length} stored credential${result.ids.length === 1 ? "" : "s"} from ${providerId}.`,
 			);
 		} catch (error: unknown) {
-			this.ctx.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+			else this.ctx.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
 
@@ -3616,75 +3681,96 @@ export class SelectorController {
 				return;
 			}
 			const authStorage = this.ctx.session.modelRegistry.authStorage;
-			const hasOAuthInventory = authStorage
-				.listCredentialInventory(selectedProviderId)
-				.some(row => row.provider === selectedProviderId && row.credentialKind === "oauth");
-			const hasRemovableCredential = authStorage
-				.listCredentialRemovalTargets(selectedProviderId)
-				.some(target => target.provider === selectedProviderId);
-			if (mode === "logout" && hasOAuthInventory && !hasRemovableCredential) {
-				await this.#handleLogout(selectedProviderId);
-				return;
-			}
-			if (hasOAuthInventory && !options?.manualCode) {
-				this.showSelector(done => {
-					let selector: OAuthSelectorComponent;
-					selector = new OAuthSelectorComponent(
-						mode,
-						authStorage,
-						() => undefined,
-						() => {
-							selector.stopValidation();
-							done();
-							this.ctx.ui.requestRender();
-						},
-						{
-							accountProviderId: selectedProviderId,
-							onAccountSelect: async (selectorValue: AuthCredentialSelector) => {
-								await this.ctx.session.setCredentialPin(selectedProviderId, selectorValue);
-								selector.stopValidation();
-								done();
-								this.ctx.showStatus(`Pinned OAuth account for ${selectedProviderId} to this session.`);
-							},
-							onAutoSelect: async () => {
-								await this.ctx.session.setCredentialAuto(selectedProviderId);
-								selector.stopValidation();
-								done();
-								this.ctx.showStatus(`Using AUTO (ranked) OAuth accounts for ${selectedProviderId}.`);
-							},
-							onAddAccount: async () => {
+			try {
+				const hasOAuthInventory = authStorage
+					.listCredentialInventory(selectedProviderId)
+					.some(row => row.provider === selectedProviderId && row.credentialKind === "oauth");
+				const hasRemovableCredential = authStorage
+					.listCredentialRemovalTargets(selectedProviderId)
+					.some(target => target.provider === selectedProviderId);
+				if (mode === "logout" && hasOAuthInventory && !hasRemovableCredential) {
+					await this.#handleLogout(selectedProviderId);
+					return;
+				}
+				if (hasOAuthInventory && !options?.manualCode) {
+					this.showSelector(done => {
+						let selector: OAuthSelectorComponent;
+						selector = new OAuthSelectorComponent(
+							mode,
+							authStorage,
+							() => undefined,
+							() => {
 								selector.stopValidation();
 								done();
-								await this.#handleOAuthLogin(selectedProviderId, options);
+								this.ctx.ui.requestRender();
 							},
-							onAccountRemove: async targets => {
-								await this.#handleLogout(selectedProviderId, targets);
-								selector.stopValidation();
-								done();
+							{
+								accountProviderId: selectedProviderId,
+								onAccountSelect: async (selectorValue: AuthCredentialSelector) => {
+									try {
+										await this.ctx.session.setCredentialPin(selectedProviderId, selectorValue);
+									} catch (error: unknown) {
+										if (!(error instanceof OAuthCredentialSelectorError)) throw error;
+										this.ctx.showError(error.message);
+										return;
+									}
+									selector.stopValidation();
+									done();
+									this.ctx.showStatus(`Pinned OAuth account for ${selectedProviderId} to this session.`);
+								},
+								onAutoSelect: async () => {
+									await this.ctx.session.setCredentialAuto(selectedProviderId);
+									selector.stopValidation();
+									done();
+									this.ctx.showStatus(`Using AUTO (ranked) OAuth accounts for ${selectedProviderId}.`);
+								},
+								onAddAccount: async () => {
+									selector.stopValidation();
+									done();
+									await this.#handleOAuthLogin(selectedProviderId, options);
+								},
+								onAccountRemove: async targets => {
+									await this.#handleLogout(selectedProviderId, targets);
+									selector.stopValidation();
+									done();
+								},
 							},
-						},
-					);
-					return { component: selector, focus: selector };
-				});
+						);
+						return { component: selector, focus: selector };
+					});
+					return;
+				}
+				if (mode === "login") {
+					await this.#handleOAuthLogin(selectedProviderId, options);
+					return;
+				}
+				// mode === "logout" with no OAuth accounts: remove stored api-key credentials directly.
+				await this.#handleLogout(selectedProviderId);
 				return;
-			}
-			if (mode === "login") {
-				await this.#handleOAuthLogin(selectedProviderId, options);
+			} catch (error: unknown) {
+				if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+				else if (isSqliteError(error))
+					this.ctx.showError(credentialStoreOperationError(mode === "login" ? "Login" : "Logout", error));
+				else throw error;
 				return;
 			}
-			// mode === "logout" with no OAuth accounts: remove stored api-key credentials directly.
-			await this.#handleLogout(selectedProviderId);
-			return;
 		}
 
 		if (mode === "logout") {
-			await this.#refreshOAuthProviderAuthState();
-			const oauthProviders = getOAuthProviders();
-			const loggedInProviders = oauthProviders.filter(provider =>
-				this.ctx.session.modelRegistry.authStorage.hasAuth(provider.id),
-			);
-			if (loggedInProviders.length === 0) {
-				this.ctx.showStatus("No OAuth providers logged in. Use /login first.");
+			try {
+				await this.#refreshOAuthProviderAuthState();
+				const oauthProviders = getOAuthProviders();
+				const loggedInProviders = oauthProviders.filter(provider =>
+					this.ctx.session.modelRegistry.authStorage.hasAuth(provider.id),
+				);
+				if (loggedInProviders.length === 0) {
+					this.ctx.showStatus("No OAuth providers logged in. Use /login first.");
+					return;
+				}
+			} catch (error: unknown) {
+				if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+				else if (isSqliteError(error)) this.ctx.showError(credentialStoreOperationError("Logout", error));
+				else throw error;
 				return;
 			}
 		}
@@ -3807,37 +3893,53 @@ export class SelectorController {
 				}
 			}
 		}
-		this.showSelector(done => {
-			let selector: OAuthSelectorComponent;
-			selector = new OAuthSelectorComponent(
-				mode,
-				this.ctx.session.modelRegistry.authStorage,
-				async (selectedProviderId: string) => {
-					selector.stopValidation();
-					done();
-					await this.showOAuthSelector(mode, selectedProviderId);
-				},
-				() => {
-					selector.stopValidation();
-					done();
-					this.ctx.ui.requestLayoutRender("oauth-selector-close");
-				},
-				{
-					validateAuth: async (selectedProviderId: string) => {
-						const apiKey = await this.ctx.session.modelRegistry.getApiKeyForProvider(
-							selectedProviderId,
-							this.ctx.session.credentialSessionId,
-						);
-						return !!apiKey;
+		try {
+			this.showSelector(done => {
+				let selector: OAuthSelectorComponent;
+				selector = new OAuthSelectorComponent(
+					mode,
+					this.ctx.session.modelRegistry.authStorage,
+					async (selectedProviderId: string) => {
+						selector.stopValidation();
+						done();
+						await this.showOAuthSelector(mode, selectedProviderId);
 					},
-					requestRender: () => {
-						this.ctx.ui.requestLayoutRender("oauth-selector-spinner");
+					() => {
+						selector.stopValidation();
+						done();
+						this.ctx.ui.requestLayoutRender("oauth-selector-close");
 					},
-					externalCredentialCandidates,
-				},
-			);
-			return { component: selector, focus: selector };
-		});
+					{
+						validateAuth: async (selectedProviderId: string) => {
+							const apiKey = await this.ctx.session.modelRegistry.getApiKeyForProvider(
+								selectedProviderId,
+								this.ctx.session.credentialSessionId,
+							);
+							return !!apiKey;
+						},
+						onValidationError: error => {
+							if (!isSqliteError(error)) return false;
+							selector.stopValidation();
+							done();
+							this.ctx.showError(
+								isSqliteCorruptionError(error)
+									? CREDENTIAL_STORE_UNREADABLE_MESSAGE
+									: credentialStoreOperationError("Login", error),
+							);
+							return true;
+						},
+						requestRender: () => {
+							this.ctx.ui.requestLayoutRender("oauth-selector-spinner");
+						},
+						externalCredentialCandidates,
+					},
+				);
+				return { component: selector, focus: selector };
+			});
+		} catch (error: unknown) {
+			if (!isSqliteCorruptionError(error)) throw error;
+			this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+		}
 	}
 
 	showDebugSelector(): void {

package/src/modes/interactive-mode.ts

@@ -45,7 +45,7 @@ import {
 	starReminderLaunchGate,
 } from "../reminders/star-reminder";
 import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+import type { AgentSession, AgentSessionEvent, AsyncJobSnapshotItem } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import { getRecentSessions, getSessionMessageEntryId } from "../session/session-manager";
@@ -186,18 +186,42 @@ export function getComposerPlaceholder(
 	return buildComposerPlaceholder(keybindings, context, options);
 }
 
+/** Running background work split into the three kinds the activity indicator names. */
+export interface BackgroundActivityTally {
+	subagents: number;
+	backgroundBash: number;
+	monitors: number;
+}
+
+/**
+ * Classify running jobs for the activity indicator using the three locked
+ * predicates: subagents are `task` jobs carrying subagent metadata, monitors
+ * are flagged by `metadata.monitor`, and background bash is a `bash` job that
+ * is not a monitor. A running job matching none of them (a task job without
+ * subagent metadata) is outside this indicator and is not counted.
+ */
+export function tallyBackgroundActivity(running: readonly AsyncJobSnapshotItem[]): BackgroundActivityTally {
+	const tally: BackgroundActivityTally = { subagents: 0, backgroundBash: 0, monitors: 0 };
+	for (const item of running) {
+		if (item.type === "task" && item.metadata?.subagent !== undefined) tally.subagents += 1;
+		else if (item.metadata?.monitor === true) tally.monitors += 1;
+		else if (item.type === "bash" && item.metadata?.backgrounded === true) tally.backgroundBash += 1;
+	}
+	return tally;
+}
+
 export function resolveActivityIndicatorMessage(
 	foregroundActive: boolean,
-	activeBackgroundTasks: number,
+	activity: BackgroundActivityTally,
 	foregroundMessage: string,
 ): string | undefined {
-	const backgroundCount = Math.max(0, Math.trunc(activeBackgroundTasks));
-	if (foregroundActive) {
-		if (backgroundCount === 0) return foregroundMessage;
-		return `${foregroundMessage} · ${backgroundCount} background task${backgroundCount === 1 ? "" : "s"}`;
-	}
-	if (backgroundCount === 0) return undefined;
-	return `Background: ${backgroundCount} task${backgroundCount === 1 ? "" : "s"}…`;
+	const parts: string[] = [];
+	if (activity.subagents > 0) parts.push(`${activity.subagents} subagent${activity.subagents === 1 ? "" : "s"}`);
+	if (activity.backgroundBash > 0) parts.push(`${activity.backgroundBash} background bash`);
+	if (activity.monitors > 0) parts.push(`${activity.monitors} monitor${activity.monitors === 1 ? "" : "s"}`);
+
+	if (foregroundActive) return parts.length === 0 ? foregroundMessage : `${foregroundMessage} · ${parts.join(", ")}`;
+	return parts.length === 0 ? undefined : `Background: ${parts.join(", ")}…`;
 }
 const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
 const COMPOSER_RIGHT_GUTTER_WIDTH = 1;
@@ -1926,8 +1950,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		return main && dim ? { main, dim } : undefined;
 	}
 
-	#activeBackgroundTaskCount(): number {
-		return this.session.getAsyncJobSnapshot()?.running.length ?? 0;
+	#activeBackgroundActivity(): BackgroundActivityTally {
+		return tallyBackgroundActivity(this.session.getAsyncJobSnapshot()?.running ?? []);
 	}
 
 	#stopLoadingAnimation(): void {
@@ -1946,7 +1970,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		const message = resolveActivityIndicatorMessage(
 			foregroundActive,
-			this.#activeBackgroundTaskCount(),
+			this.#activeBackgroundActivity(),
 			this.#pendingWorkingMessage ?? this.#defaultWorkingMessage,
 		);
 		if (!message) {

package/src/modes/print-mode.ts

@@ -5,6 +5,7 @@
  * - `gjc -p "prompt"` - text output
  * - `gjc --mode json "prompt"` - JSON event stream
  */
+import type { AgentMessage } from "@gajae-code/agent-core";
 import { type AssistantMessage, type ImageContent, isContextOverflow } from "@gajae-code/ai/core";
 import { isKnownSinkPeerClosedError, logger, sanitizeText } from "@gajae-code/utils";
 import { loadSlashCommands } from "../extensibility/slash-commands";
@@ -46,6 +47,48 @@ export interface PrintModeOptions {
  */
 export const CONTEXT_OVERFLOW_EXIT_CODE = 78;
 
+const EMPTY_TURN_ERROR = {
+	code: "empty_response",
+	message: "Turn completed without assistant text.",
+} as const;
+
+export type PrintTerminalDisposition =
+	| { status: "success"; assistantText: true }
+	| { status: "failure"; error: typeof EMPTY_TURN_ERROR | { code: "assistant_error"; message: string } };
+
+function assistantText(message: AssistantMessage): string {
+	return message.content
+		.filter((content): content is { type: "text"; text: string } => content.type === "text")
+		.map(content => content.text)
+		.join("");
+}
+
+export function resolvePrintTerminalDisposition(
+	messages: readonly AgentMessage[],
+	submittedPrompt: boolean,
+	turnStartIndex?: number,
+): PrintTerminalDisposition | undefined {
+	if (!submittedPrompt) return undefined;
+	const turnMessages = turnStartIndex === undefined ? messages : messages.slice(turnStartIndex);
+	const lastAssistant = turnMessages.findLast((message): message is AssistantMessage => message.role === "assistant");
+	if (!lastAssistant) return { status: "failure", error: EMPTY_TURN_ERROR };
+	if (
+		(lastAssistant.stopReason === "error" || lastAssistant.stopReason === "aborted") &&
+		!isSilentAbort(lastAssistant.errorMessage)
+	) {
+		return {
+			status: "failure",
+			error: {
+				code: "assistant_error",
+				message: sanitizeText(lastAssistant.errorMessage || `Request ${lastAssistant.stopReason}`),
+			},
+		};
+	}
+	if (isSilentAbort(lastAssistant.errorMessage)) return undefined;
+	if (assistantText(lastAssistant).trim().length === 0) return { status: "failure", error: EMPTY_TURN_ERROR };
+	return { status: "success", assistantText: true };
+}
+
 /**
  * Build an actionable stderr diagnostic for a terminal context-overflow error in
  * text mode. The raw provider message is preserved (appended) for debugging, but
@@ -201,6 +244,8 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 	let unsubscribe: (() => void) | undefined;
 	let submittedPrompt = false;
 	let consumedCommand = false;
+	let jsonFailureObserved = false;
+	let lastPromptMessageStart: number | undefined;
 
 	try {
 		for (const warning of new Set(session.configWarnings)) {
@@ -237,6 +282,14 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		// when it must render the JSON event stream.
 		if (mode === "json") {
 			unsubscribe = session.subscribe(event => {
+				if (
+					event.type === "agent_failed" ||
+					(event.type === "message_end" &&
+						event.message.role === "assistant" &&
+						(event.message.stopReason === "error" || event.message.stopReason === "aborted"))
+				) {
+					jsonFailureObserved = true;
+				}
 				stdout.write(`${JSON.stringify(event)}\n`);
 			});
 		}
@@ -265,6 +318,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				if (command !== false) text = command.prompt;
 			}
 			submittedPrompt = true;
+			lastPromptMessageStart = session.state.messages.length;
 			await session.prompt(text, images ? { images } : undefined);
 		};
 
@@ -277,6 +331,16 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			await logger.time("print:prompt:next", () => submitInput(message));
 		}
 
+		const terminal = resolvePrintTerminalDisposition(session.state.messages, submittedPrompt, lastPromptMessageStart);
+		if (terminal?.status === "failure") {
+			if (!options.suppressProcessExit) process.exitCode = 1;
+			if (mode === "json" && !jsonFailureObserved) {
+				stdout.write(`${JSON.stringify({ type: "agent_failed", error: terminal.error })}\n`);
+			} else if (mode === "text" && terminal.error.code === EMPTY_TURN_ERROR.code) {
+				await writeStderrAndQuiesce(`${terminal.error.message}\n`);
+			}
+		}
+
 		// In text mode, output final response.
 		if (mode === "text" && (!consumedCommand || submittedPrompt)) {
 			const lastMessage = session.state.messages.findLast(message => message.role === "assistant");

package/src/modes/prompt-action-autocomplete.ts

@@ -6,6 +6,8 @@ import {
 	CombinedAutocompleteProvider,
 	extractSlashCommandTokenPrefix,
 	getSlashCommandMatchRank,
+	hasInlineCodeDelimiter,
+	isInsideInlineCodeSpan,
 	normalizeFuzzyText,
 	type SlashCommand,
 } from "@gajae-code/tui";
@@ -140,7 +142,7 @@ function withoutSkillCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
 ): { items: AutocompleteItem[]; prefix: string } | null {
 	if (!suggestions) return null;
-	const items = suggestions.items.filter(item => !item.value.startsWith("skill:"));
+	const items = suggestions.items.filter(item => !item.value.toLowerCase().startsWith("skill:"));
 	return items.length > 0 ? { ...suggestions, items } : null;
 }
 
@@ -160,6 +162,21 @@ function getSlashTokenPrefix(textBeforeCursor: string): string | null {
 	return extractSlashCommandTokenPrefix(textBeforeCursor);
 }
 
+function getRawSlashTokenPrefix(textBeforeCursor: string): string | null {
+	return textBeforeCursor.match(/(?:^|\s)(\/[^\s]*)$/)?.[1] ?? null;
+}
+
+function isSlashTokenInsideInlineCodeSpan(
+	lines: string[],
+	cursorLine: number,
+	textBeforeCursor: string,
+	prefix: string,
+): boolean {
+	const tokenStart = textBeforeCursor.length - prefix.length;
+	const textBeforeToken = [...lines.slice(0, cursorLine), textBeforeCursor.slice(0, tokenStart)].join("\n");
+	return isInsideInlineCodeSpan(textBeforeToken);
+}
+
 export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
@@ -211,8 +228,13 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			}
 		}
 
+		const rawSlashPrefix = getRawSlashTokenPrefix(textBeforeCursor);
 		const slashPrefix = getSlashTokenPrefix(textBeforeCursor);
-		if (slashPrefix) {
+		const slashTokenInsideCode =
+			rawSlashPrefix !== null &&
+			(hasInlineCodeDelimiter(rawSlashPrefix) ||
+				isSlashTokenInsideInlineCodeSpan(lines, cursorLine, textBeforeCursor, rawSlashPrefix));
+		if (slashPrefix && !slashTokenInsideCode) {
 			const baseSuggestions = withoutSkillCommandSuggestions(
 				await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol),
 			);
@@ -225,6 +247,9 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 				this.#commands,
 			);
 		}
+		if (rawSlashPrefix && slashTokenInsideCode) {
+			return withoutSkillCommandSuggestions(await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol));
+		}
 
 		if (!isSettingsInitialized() || settings.get("emojiAutocomplete")) {
 			const emojiSuggestions = getEmojiSuggestions(textBeforeCursor);
@@ -282,12 +307,13 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			const currentLine = lines[cursorLine] || "";
 			const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
 			const afterCursor = currentLine.slice(cursorCol);
+			const separator = afterCursor.length === 0 ? " " : "";
 			const newLines = [...lines];
-			newLines[cursorLine] = `${beforePrefix}/${item.value} ${afterCursor}`;
+			newLines[cursorLine] = `${beforePrefix}/${item.value}${separator}${afterCursor}`;
 			return {
 				lines: newLines,
 				cursorLine,
-				cursorCol: beforePrefix.length + item.value.length + 2,
+				cursorCol: beforePrefix.length + item.value.length + 1 + separator.length,
 			};
 		}
 		return this.#baseProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);