@gajae-code/coding-agent 0.18.7 → 0.18.9

package/src/internal-urls/skill-path.ts

@@ -0,0 +1,19 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export async function realSkillPath(baseDir: string, targetPath: string): Promise<string> {
+	const realBase = await fs.realpath(baseDir);
+	let realTarget: string;
+	try {
+		realTarget = await fs.realpath(targetPath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			throw new Error(`File not found: ${targetPath}`);
+		}
+		throw error;
+	}
+	if (realTarget !== realBase && !realTarget.startsWith(realBase + path.sep)) {
+		throw new Error("Path traversal is not allowed");
+	}
+	return realTarget;
+}

package/src/internal-urls/skill-protocol.ts

@@ -9,6 +9,7 @@
  */
 import * as path from "node:path";
 import { getActiveSkills } from "../extensibility/skills";
+import { realSkillPath } from "./skill-path";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
@@ -70,6 +71,7 @@ export class SkillProtocolHandler implements ProtocolHandler {
 			if (!resolvedPath.startsWith(resolvedBaseDir + path.sep) && resolvedPath !== resolvedBaseDir) {
 				throw new Error("Path traversal is not allowed");
 			}
+			targetPath = await realSkillPath(skill.baseDir, targetPath);
 		} else {
 			targetPath = skill.filePath;
 		}

package/src/lsp/config.ts

@@ -276,75 +276,19 @@ export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 }
 
 // =============================================================================
-// Local Binary Resolution
+// Trusted executable resolution
 // =============================================================================
 
 /**
- * Local bin directories to check before $PATH, ordered by priority.
- * Each entry maps a root marker to the bin directory to check.
- */
-const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
-	// Node.js - check node_modules/.bin/
-	{ markers: ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"], binDir: "node_modules/.bin" },
-	// Python - check virtual environment bin directories
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: ".venv/bin" },
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: "venv/bin" },
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: ".env/bin" },
-	// Ruby - check vendor bundle and binstubs
-	{ markers: ["Gemfile", "Gemfile.lock"], binDir: "vendor/bundle/bin" },
-	{ markers: ["Gemfile", "Gemfile.lock"], binDir: "bin" },
-	// Go - check project-local bin
-	{ markers: ["go.mod", "go.sum"], binDir: "bin" },
-];
-
-const WINDOWS_LOCAL_EXECUTABLE_EXTENSIONS = [".exe", ".cmd", ".bat"] as const;
-
-function resolveLocalCommand(basePath: string): string | null {
-	if (fs.existsSync(basePath)) return basePath;
-	if (process.platform !== "win32") return null;
-
-	// Package managers write Windows launchers with executable suffixes in node_modules/.bin.
-	for (const extension of WINDOWS_LOCAL_EXECUTABLE_EXTENSIONS) {
-		const candidate = `${basePath}${extension}`;
-		if (fs.existsSync(candidate)) return candidate;
-	}
-
-	return null;
-}
-
-/**
- * Resolve a command to an executable path.
- * Checks project-local bin directories first, then falls back to $PATH.
- *
- * @param command - The command name (e.g., "typescript-language-server")
- * @param cwd - Working directory to search from
- * @returns Absolute path to the executable, or null if not found
- */
-export function resolveCommand(command: string, cwd: string): string | null {
-	// Check local bin directories based on project markers
-	for (const { markers, binDir } of LOCAL_BIN_PATHS) {
-		if (hasRootMarkers(cwd, markers)) {
-			const localPath = path.join(cwd, binDir, command);
-			const resolvedLocalPath = resolveLocalCommand(localPath);
-			if (resolvedLocalPath) {
-				return resolvedLocalPath;
-			}
-		}
-	}
-
-	// Fall back to $PATH
-	return piUtils.$which(command);
-}
-
-/**
- * Resolve an LSP executable without consulting project-controlled bin directories.
+ * Resolve a host-spawn executable from $PATH without consulting project-controlled bin directories.
+ * LSP auto-detection and DAP adapter launch both use this rule.
  *
  * Trust is evaluated on both the discovered and canonical paths, but the returned
  * path is the discovered one: multiplexed launchers such as rustup pick the proxied
  * tool from argv[0], so `~/.cargo/bin/rust-analyzer -> rustup` must be spawned as
  * `rust-analyzer`, not as the resolved `rustup` binary.
  */
-function resolveTrustedLspCommand(command: string, cwd: string): string | null {
+export function resolveTrustedCommand(command: string, cwd: string): string | null {
 	if (!path.isAbsolute(command) && (command.includes("/") || command.includes("\\"))) return null;
 	const discovered = path.isAbsolute(command) ? command : piUtils.$which(command);
 	if (!discovered) return null;
@@ -353,6 +297,11 @@ function resolveTrustedLspCommand(command: string, cwd: string): string | null {
 	return discovered;
 }
 
+/** Same rule as `resolveTrustedCommand`: project-local bin directories are never searched. */
+export function resolveCommand(command: string, cwd: string): string | null {
+	return resolveTrustedCommand(command, cwd);
+}
+
 interface ConfigSource {
 	allowProcessOverrides: boolean;
 	read(): LoadedConfigSource | null;
@@ -556,8 +505,8 @@ export function loadConfig(cwd: string): LspConfig {
 			// Check if project has root markers for this language
 			if (!hasRootMarkers(cwd, config.rootMarkers)) continue;
 
-			// Check if the language server binary is available (local or $PATH)
-			const resolved = resolveTrustedLspCommand(config.command, cwd);
+			// Check if a trusted language server binary is available on $PATH.
+			const resolved = resolveTrustedCommand(config.command, cwd);
 			if (!resolved) continue;
 
 			detected[name] = { ...config, resolvedCommand: resolved };
@@ -572,7 +521,7 @@ export function loadConfig(cwd: string): LspConfig {
 	for (const [name, config] of Object.entries(mergedWithRuntime)) {
 		if (config.disabled) continue;
 		if (!hasRootMarkers(cwd, config.rootMarkers)) continue;
-		const resolved = resolveTrustedLspCommand(config.command, cwd);
+		const resolved = resolveTrustedCommand(config.command, cwd);
 		if (!resolved) continue;
 		available[name] = { ...config, resolvedCommand: resolved };
 	}

package/src/lsp/edits.ts

@@ -13,6 +13,7 @@ import type {
 	WorkspaceEdit,
 } from "./types";
 import { uriToFile } from "./utils";
+import { assertInsideWorkspace } from "./workspace-path";
 
 // =============================================================================
 // Text Edit Application
@@ -133,6 +134,7 @@ export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Prom
 	const textEditsByUri = flattenWorkspaceTextEdits(edit);
 	for (const [uri, textEdits] of textEditsByUri) {
 		const filePath = uriToFile(uri);
+		await assertInsideWorkspace(cwd, filePath);
 		await applyTextEdits(filePath, textEdits);
 		applied.push(`Applied ${textEdits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
 	}
@@ -144,18 +146,22 @@ export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Prom
 			if (change.kind === "create") {
 				const createOp = change as CreateFile;
 				const filePath = uriToFile(createOp.uri);
+				await assertInsideWorkspace(cwd, filePath);
 				await Bun.write(filePath, "");
 				applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
 			} else if (change.kind === "rename") {
 				const renameOp = change as RenameFile;
 				const oldPath = uriToFile(renameOp.oldUri);
 				const newPath = uriToFile(renameOp.newUri);
+				await assertInsideWorkspace(cwd, oldPath);
+				await assertInsideWorkspace(cwd, newPath);
 				await fs.mkdir(path.dirname(newPath), { recursive: true });
 				await fs.rename(oldPath, newPath);
 				applied.push(`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`);
 			} else if (change.kind === "delete") {
 				const deleteOp = change as DeleteFile;
 				const filePath = uriToFile(deleteOp.uri);
+				await assertInsideWorkspace(cwd, filePath);
 				await fs.rm(filePath, { recursive: true });
 				applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
 			}

package/src/lsp/workspace-path.ts

@@ -0,0 +1,51 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { ToolError } from "../tools/tool-errors";
+
+function isEnoent(error: unknown): boolean {
+	return (error as NodeJS.ErrnoException).code === "ENOENT";
+}
+
+function escapes(root: string, candidate: string): boolean {
+	return candidate !== root && !candidate.startsWith(`${root}${path.sep}`);
+}
+
+/** Resolve a missing path through the nearest existing ancestor. */
+async function canonicalize(filePath: string): Promise<string> {
+	try {
+		return await fs.realpath(filePath);
+	} catch (error) {
+		if (!isEnoent(error)) throw error;
+	}
+
+	const missing: string[] = [];
+	let cursor = filePath;
+	for (;;) {
+		let stat: Awaited<ReturnType<typeof fs.lstat>> | undefined;
+		try {
+			stat = await fs.lstat(cursor);
+		} catch (error) {
+			if (!isEnoent(error)) throw error;
+		}
+		if (stat) {
+			try {
+				return path.join(await fs.realpath(cursor), ...missing);
+			} catch (error) {
+				if (isEnoent(error)) throw new ToolError(`LSP edit escapes the workspace: ${filePath}`);
+				throw error;
+			}
+		}
+		const parent = path.dirname(cursor);
+		if (parent === cursor) throw new ToolError(`LSP edit escapes the workspace: ${filePath}`);
+		missing.unshift(path.basename(cursor));
+		cursor = parent;
+	}
+}
+
+export async function assertInsideWorkspace(cwd: string, filePath: string): Promise<void> {
+	const root = await fs.realpath(cwd);
+	const candidate = await canonicalize(filePath);
+	if (escapes(root, candidate)) {
+		throw new ToolError(`LSP edit escapes the workspace: ${filePath}`);
+	}
+}

package/src/main.ts

@@ -475,6 +475,11 @@ type StartupModelProfileArgs = {
 	preferCachedDefaultProfile?: boolean;
 };
 
+type StartupModelProfileFailure = {
+	profileName: string;
+	error: ModelProfileCredentialError | UnknownModelProfileError;
+};
+
 function staleDefaultProfileMessage(error: UnknownModelProfileError, profileCatalogRefreshUnavailable = false): string {
 	const refreshNotice = profileCatalogRefreshUnavailable
 		? " The online profile catalog could not be refreshed; continuing with the last accepted catalog."
@@ -488,6 +493,8 @@ async function applyStartupModelProfilesWithPolicy(
 	onUnknownDefault?: (error: UnknownModelProfileError, profileCatalogRefreshUnavailable: boolean) => void,
 ): Promise<void> {
 	let profileCatalogRefreshUnavailable = false;
+	let profilePassFailures: StartupModelProfileFailure[] = [];
+	let unhandledProfileName: string | undefined;
 	const applyProfile = async (
 		profileName: string,
 		persistDefault: boolean,
@@ -496,37 +503,66 @@ async function applyStartupModelProfilesWithPolicy(
 			tolerateCredentialError?: boolean;
 			tolerateUnknownDefault?: boolean;
 			runtimeBindingsOnly?: boolean;
+			userSelectionRevision?: number;
 		} = {},
 	): Promise<boolean> => {
-		try {
+		const isCurrent =
+			options.userSelectionRevision === undefined
+				? undefined
+				: () => args.session.getUserModelSelectionRevision() === options.userSelectionRevision;
+		if (isCurrent && !isCurrent()) return false;
+		const apply = async (): Promise<boolean> => {
+			if (isCurrent && !isCurrent()) return false;
 			if (options.runtimeBindingsOnly) {
-				await applyModelProfileRuntimeBindings({
-					session: args.session,
-					modelRegistry: args.modelRegistry,
-					settings: args.settings,
-					profileName,
-				});
+				await applyModelProfileRuntimeBindings(
+					{
+						session: args.session,
+						modelRegistry: args.modelRegistry,
+						settings: args.settings,
+						profileName,
+					},
+					isCurrent,
+				);
 			} else {
 				await activateModelProfile(
 					{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
-					{ persistDefault, thinkingLevelOverride: options.thinkingLevelOverride },
+					{
+						persistDefault,
+						thinkingLevelOverride: options.thinkingLevelOverride,
+						isCurrent,
+					},
 				);
 			}
 			return true;
+		};
+		try {
+			return isCurrent ? await args.session.withSdkControlMutation(apply) : await apply();
 		} catch (error) {
 			if (error instanceof ModelProfileCredentialError && (onCredentialError || options.tolerateCredentialError)) {
-				if (onCredentialError) onCredentialError(error);
-				else process.stderr.write(`${chalk.yellow(`Warning: ${error.message}`)}\n`);
+				profilePassFailures.push({ profileName, error });
+				logger.warn("Startup model profile not applied: missing provider credentials", {
+					profile: profileName,
+					errorClass: error.name,
+					providers: error.providers,
+					role: error.role,
+				});
+				if (!onCredentialError) process.stderr.write(`${chalk.yellow(`Warning: ${error.message}`)}\n`);
 				return false;
 			}
 			if (error instanceof UnknownModelProfileError && options.tolerateUnknownDefault) {
-				if (onUnknownDefault) onUnknownDefault(error, profileCatalogRefreshUnavailable);
-				else
+				profilePassFailures.push({ profileName, error });
+				logger.warn("Startup model profile not applied: unknown profile", {
+					profile: profileName,
+					errorClass: error.name,
+					catalogRefreshUnavailable: profileCatalogRefreshUnavailable,
+				});
+				if (!onUnknownDefault)
 					process.stderr.write(
 						`${chalk.yellow(`Warning: ${staleDefaultProfileMessage(error, profileCatalogRefreshUnavailable)}`)}\n`,
 					);
 				return false;
 			}
+			unhandledProfileName = profileName;
 			throw error;
 		}
 	};
@@ -546,9 +582,16 @@ async function applyStartupModelProfilesWithPolicy(
 	const preferCachedProfiles =
 		(args.preferCachedModels === true && args.parsedArgs.mpreset !== undefined) ||
 		(args.preferCachedDefaultProfile === true && defaultProfile !== undefined);
-	const applyConfiguredProfiles = async (allowMissingDefault: boolean): Promise<boolean> => {
+	let modelSelectionChangedDuringRecovery = false;
+	const applyConfiguredProfiles = async (
+		allowMissingDefault: boolean,
+		profileNames?: ReadonlySet<string>,
+		userSelectionRevision?: number,
+	): Promise<boolean> => {
+		profilePassFailures = [];
+		unhandledProfileName = undefined;
 		let applied = true;
-		if (defaultProfile) {
+		if (defaultProfile && (!profileNames || profileNames.has(defaultProfile))) {
 			applied =
 				(await applyProfile(defaultProfile, false, {
 					thinkingLevelOverride: args.settings.has("defaultThinkingLevel")
@@ -556,37 +599,141 @@ async function applyStartupModelProfilesWithPolicy(
 						: undefined,
 					tolerateCredentialError: tolerateDefaultProfileFailure,
 					tolerateUnknownDefault:
-						allowMissingDefault && (onUnknownDefault !== undefined || tolerateDefaultProfileFailure),
+						onUnknownDefault !== undefined || (allowMissingDefault && tolerateDefaultProfileFailure),
 					runtimeBindingsOnly: args.session.hasRecoveredDefaultFallbackChain(),
+					userSelectionRevision,
 				})) && applied;
 		}
-		if (args.parsedArgs.mpreset) {
-			applied = (await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true)) && applied;
+		if (args.parsedArgs.mpreset && (!profileNames || profileNames.has(args.parsedArgs.mpreset))) {
+			applied =
+				(await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true, {
+					userSelectionRevision,
+				})) && applied;
 		}
 		return applied;
 	};
+	const profilesFromFirstFailure = (failedProfiles: ReadonlySet<string>): ReadonlySet<string> => {
+		const orderedProfiles = [defaultProfile, args.parsedArgs.mpreset].filter(
+			(name): name is string => name !== undefined,
+		);
+		const firstFailureIndex = orderedProfiles.findIndex(name => failedProfiles.has(name));
+		return firstFailureIndex === -1 ? failedProfiles : new Set(orderedProfiles.slice(firstFailureIndex));
+	};
+	const applyFailedProfiles = async (
+		failedProfiles: ReadonlySet<string>,
+		userSelectionRevision: number,
+	): Promise<boolean> => {
+		const applied = await applyConfiguredProfiles(true, failedProfiles, userSelectionRevision);
+		if (
+			applied &&
+			defaultProfile !== undefined &&
+			failedProfiles.has(defaultProfile) &&
+			args.parsedArgs.mpreset !== undefined &&
+			!failedProfiles.has(args.parsedArgs.mpreset)
+		) {
+			return applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true, { userSelectionRevision });
+		}
+		return applied;
+	};
+	const refreshAuthAndCatalog = async (continueOnRefreshError: boolean): Promise<void> => {
+		try {
+			await args.modelRegistry.authStorage?.reload();
+		} catch (error) {
+			logger.warn("Failed to reload auth before startup model profile recovery", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		try {
+			await args.modelRegistry.refreshModelPresetProfilesFromRegistry();
+		} catch (error) {
+			if (!continueOnRefreshError && args.modelRegistry.getError()) throw error;
+			profileCatalogRefreshUnavailable = true;
+			logger.warn("Failed to refresh model profile catalog before startup recovery", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		try {
+			await args.modelRegistry.refresh("online-if-uncached", args.session.credentialSessionId);
+		} catch (error) {
+			if (!continueOnRefreshError) throw error;
+			logger.warn("Failed to refresh model catalog before startup profile recovery", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+	const reportFinalProfileFailures = (markDefaultUnavailable = true): void => {
+		for (const failure of profilePassFailures) {
+			if (failure.error instanceof ModelProfileCredentialError) {
+				onCredentialError?.(failure.error);
+			} else {
+				onUnknownDefault?.(failure.error, profileCatalogRefreshUnavailable);
+			}
+		}
+		if (
+			markDefaultUnavailable &&
+			(onCredentialError || onUnknownDefault) &&
+			args.parsedArgs.mpreset === undefined &&
+			args.parsedArgs.model === undefined
+		) {
+			const defaultFailure = profilePassFailures.find(failure => failure.profileName === defaultProfile);
+			if (defaultFailure) args.session.setUnavailableModelProfile(defaultFailure.profileName);
+		}
+	};
 
+	// Deferred --mpreset startup can overlap selector input; never reapply its
+	// captured profile after the user has selected a newer model.
 	if (preferCachedProfiles) {
 		let applied: boolean;
 		let refreshedOnline = false;
+		const selectionRevision = args.session.getUserModelSelectionRevision();
 		try {
-			applied = await applyConfiguredProfiles(false);
+			applied = await applyConfiguredProfiles(false, undefined, selectionRevision);
 		} catch (error) {
 			if (error instanceof ModelProfileCredentialError) throw error;
 			if (error instanceof UnknownModelProfileError) {
-				try {
-					await args.modelRegistry.refreshModelPresetProfilesFromRegistry();
-				} catch (refreshError) {
-					if (args.modelRegistry.getError()) throw refreshError;
-					profileCatalogRefreshUnavailable = true;
-					logger.warn("Failed to refresh model profile catalog before startup recovery", {
-						error: refreshError instanceof Error ? refreshError.message : String(refreshError),
-					});
-				}
+				await refreshAuthAndCatalog(onCredentialError !== undefined || onUnknownDefault !== undefined);
+			} else {
+				await args.modelRegistry.refresh("online-if-uncached", args.session.credentialSessionId);
 			}
-			await args.modelRegistry.refresh("online-if-uncached", args.session.credentialSessionId);
+			if (args.session.getUserModelSelectionRevision() !== selectionRevision) return;
 			refreshedOnline = true;
-			applied = await applyConfiguredProfiles(true);
+			const failedProfiles = new Set(profilePassFailures.map(failure => failure.profileName));
+			if (unhandledProfileName) failedProfiles.add(unhandledProfileName);
+			const profilesToRetry = profilesFromFirstFailure(failedProfiles);
+			applied = await applyConfiguredProfiles(
+				true,
+				profilesToRetry.size > 0 ? profilesToRetry : undefined,
+				selectionRevision,
+			);
+			if (args.session.getUserModelSelectionRevision() !== selectionRevision) return;
+		}
+		if (args.session.getUserModelSelectionRevision() !== selectionRevision) {
+			modelSelectionChangedDuringRecovery = true;
+			applied = false;
+		}
+		if (
+			!modelSelectionChangedDuringRecovery &&
+			!applied &&
+			profilePassFailures.length > 0 &&
+			(onCredentialError !== undefined || onUnknownDefault !== undefined)
+		) {
+			if (!refreshedOnline) {
+				const failedProfiles = new Set(profilePassFailures.map(failure => failure.profileName));
+				await refreshAuthAndCatalog(true);
+				refreshedOnline = true;
+				if (args.session.getUserModelSelectionRevision() !== selectionRevision) {
+					modelSelectionChangedDuringRecovery = true;
+					applied = false;
+				} else {
+					applied = await applyFailedProfiles(failedProfiles, selectionRevision);
+					if (args.session.getUserModelSelectionRevision() !== selectionRevision) {
+						modelSelectionChangedDuringRecovery = true;
+						applied = false;
+					}
+				}
+			}
+			if (applied) args.session.setUnavailableModelProfile(undefined);
+			else reportFinalProfileFailures(!modelSelectionChangedDuringRecovery);
 		}
 		if (applied && !refreshedOnline)
 			args.modelRegistry.refreshInBackground("online-if-uncached", args.session.credentialSessionId);
@@ -598,7 +745,7 @@ async function applyStartupModelProfilesWithPolicy(
 	}
 
 	// Explicit CLI --model/--thinking must win over any activated or skipped profile.
-	if (explicitModel) {
+	if (explicitModel && !modelSelectionChangedDuringRecovery) {
 		await args.session.setModelTemporary(explicitModel, args.startupThinkingLevel ?? args.parsedArgs.thinking, {
 			persistAsSessionDefault: true,
 			cause: "startup-override",
@@ -606,7 +753,7 @@ async function applyStartupModelProfilesWithPolicy(
 		const selector = `${explicitModel.provider}/${explicitModel.id}`;
 		args.session.setConfiguredModelChain("default", [selector], "startup-override", undefined, true);
 		args.session.seedDefaultFallbackResolution(0, []);
-	} else if (args.parsedArgs.thinking && args.session.model) {
+	} else if (!modelSelectionChangedDuringRecovery && args.parsedArgs.thinking && args.session.model) {
 		await args.session.setModelTemporary(args.session.model, args.parsedArgs.thinking, { cause: "startup-override" });
 	}
 }
@@ -975,6 +1122,21 @@ export async function runInteractiveMode(
 		);
 	}
 
+	// Startup input bypasses the editor submit path, so seed the automatic title
+	// here. Only text that `prompt` actually dispatches to a loaded skill is
+	// skipped; unknown `/skill:` text is submitted as an ordinary prompt and is
+	// titled like one. It must run before the prompt (the title gate skips
+	// sessions that already hold a user message), and a title failure must never
+	// drop the prompt.
+	const maybeGenerateStartupTitle = (text: string, images?: readonly unknown[]): void => {
+		try {
+			if (session.resolvePromptSkillInvocation(text, images) || session.isLocallyHandledSlashCommand(text)) return;
+			mode.maybeGenerateSessionTitle(text);
+		} catch (error: unknown) {
+			logger.warn("Startup session title generation failed", { error: String(error) });
+		}
+	};
+
 	const runStartupInputAndPromptLoop = async (): Promise<never> => {
 		const hasStartupInput = initialMessage !== undefined || initialMessages.length > 0;
 		if (!hasStartupInput && resumeAction === "continue-tail") {
@@ -988,6 +1150,7 @@ export async function runInteractiveMode(
 
 		if (initialMessage !== undefined) {
 			try {
+				maybeGenerateStartupTitle(initialMessage, initialImages);
 				await session.prompt(initialMessage, { images: initialImages });
 			} catch (error: unknown) {
 				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
@@ -1004,6 +1167,7 @@ export async function runInteractiveMode(
 				});
 				if (slashResult === true) continue;
 				if (typeof slashResult === "string") text = slashResult;
+				maybeGenerateStartupTitle(text);
 				await session.prompt(text);
 			} catch (error: unknown) {
 				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";