@gajae-code/coding-agent 0.18.7 → 0.18.8

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/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";

package/src/modes/acp/acp-agent.ts

@@ -38,6 +38,8 @@ import {
 } from "@agentclientprotocol/sdk";
 import { getAgentDir, logger, resolveEquivalentPath } from "@gajae-code/utils";
 import packageJson from "../../../package.json" with { type: "json" };
+import { PROJECT_PROGRESS_SNAPSHOT_SCHEMA, type ProjectProgressSnapshot } from "../../progress/progress-contract";
+import { PROGRESS_COMMAND_ACP_DESCRIPTION, renderProgressSnapshot } from "../../progress/render-progress";
 import {
 	ACP_SESSION_RECONNECT,
 	type AcpProviderRegistration,
@@ -258,6 +260,8 @@ type PendingAttachment = { epoch: number; task: Promise<void> };
 
 type PromptAdmissionSettlement = { kind: "cancelled" } | { kind: "rejected"; error: AcpSdkAdapterError };
 type PromptAdmissionReservation = {
+	/** Held by a model-free builtin (`/progress`) answered locally; no host turn exists to abort. */
+	localCommand?: true;
 	cancelled?: boolean;
 	settlement?: PromptAdmissionSettlement;
 	wake: () => void;
@@ -526,9 +530,12 @@ function pageItems(value: unknown): unknown[] {
 	return Array.isArray(page?.items) ? page.items : [];
 }
 
+/** Builtin `/progress`: answered locally from the read-only `session.progress` SDK query, never a model turn. */
+const ACP_PROGRESS_COMMAND: AvailableCommand = { name: "progress", description: PROGRESS_COMMAND_ACP_DESCRIPTION };
+
 /** Build the ACP command palette from the shared builtins and live SDK skill state. */
 export function acpAvailableCommandsFromSkills(query: unknown): AvailableCommand[] {
-	const commands = new Map<string, AvailableCommand>();
+	const commands = new Map<string, AvailableCommand>([[ACP_PROGRESS_COMMAND.name, ACP_PROGRESS_COMMAND]]);
 	for (const item of pageItems(query)) {
 		const skill = object(item);
 		if (typeof skill?.name !== "string" || !skill.name) continue;
@@ -1508,6 +1515,22 @@ export function acpSkillInvocation(blocks: PromptRequest["prompt"]): { name: str
 	return { name: match[1], args: match[2]?.trim() ?? "" };
 }
 
+/**
+ * Recognize the builtin `/progress` command only when it is the complete, single text
+ * prompt. Like the TUI (`allowArgs: false`), `/progress <args>` is not the command.
+ */
+export function isAcpProgressCommand(blocks: PromptRequest["prompt"]): boolean {
+	return blocks.length === 1 && blocks[0]?.type === "text" && blocks[0].text.trim() === "/progress";
+}
+
+/** Render the `session.progress` query result as the plain-text `/progress` view. */
+export function acpProgressReportText(query: unknown): string {
+	const snapshot = object(pageItems(query)[0]);
+	if (snapshot?.schema !== PROJECT_PROGRESS_SNAPSHOT_SCHEMA)
+		throw new AcpSdkAdapterError("unavailable", "SDK session.progress response omitted the progress snapshot.");
+	return renderProgressSnapshot(snapshot as unknown as ProjectProgressSnapshot).join("\n");
+}
+
 /** Convert every ACP prompt block the agent advertises without silently discarding context. */
 export function acpPromptPayload(blocks: PromptRequest["prompt"]): {
 	text: string;
@@ -2398,6 +2421,38 @@ export class AcpAgent implements Agent {
 		}
 	}
 
+	/**
+	 * Read-only builtin `/progress`: answered from the session.progress query instead of a
+	 * model turn. It owns prompt admission (`pendingPromptAdmission`) from the query until its
+	 * response is published, so a concurrent prompt is refused as `conflict` exactly as it is
+	 * while a model turn is active. `cancel` and session teardown settle that reservation
+	 * through the existing admission paths; this command observes it and stops publishing.
+	 */
+	async #runProgressCommand(sessionId: string, record: SessionRecord): Promise<PromptResponse> {
+		const { promise: woken, resolve: wake } = Promise.withResolvers<void>();
+		const reservation: PromptAdmissionReservation = { localCommand: true, wake, woken };
+		// Replaces a follow-up reservation this prompt already consumed; `#submitPrompt` only
+		// clears the reservation it installed, so ownership stays with this command.
+		record.pendingPromptAdmission = reservation;
+		try {
+			const query = record.adapter.query("session.progress");
+			void query.catch(() => undefined);
+			const result = await Promise.race([query.then(value => ({ value })), woken.then(() => undefined)]);
+			const settlement = reservation.settlement;
+			if (settlement?.kind === "rejected") throw settlement.error;
+			if (settlement?.kind === "cancelled" || reservation.cancelled || !result) return { stopReason: "cancelled" };
+			const text = acpProgressReportText(result.value);
+			await this.#publishSessionUpdate(
+				sessionId,
+				{ sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } } },
+				record.adapter,
+			);
+			return { stopReason: "end_turn" };
+		} finally {
+			if (record.pendingPromptAdmission === reservation) record.pendingPromptAdmission = undefined;
+		}
+	}
+
 	async #waitForPromptSettlement(
 		waiter: PromptWaiter,
 		admissionReservation: PromptAdmissionReservation,
@@ -2482,6 +2537,7 @@ export class AcpAgent implements Agent {
 			);
 			return { stopReason: "end_turn" };
 		}
+		if (isAcpProgressCommand(params.prompt)) return await this.#runProgressCommand(params.sessionId, record);
 		// The SDK transport hard-caps a single request frame at 256 KiB and answers an
 		// oversize frame by closing the socket (CloseCode::Size, crates/gjc-sdk/src/server.rs),
 		// which surfaces to the client as an opaque `connection_closed` mid-turn. Reject
@@ -2969,6 +3025,7 @@ export class AcpAgent implements Agent {
 		// Record the client's intent before awaiting the SDK so a prompt that rejects
 		// mid-cancel (e.g. preflight `busy`) can still settle as `cancelled`.
 		record.cancelRequested = true;
+		const localCommand = !record.activePrompt && record.pendingPromptAdmission?.localCommand === true;
 		this.#settlePendingPromptAdmission(record, { kind: "cancelled" });
 		// C04 terminal abort: an external client cancel stops the current turn
 		// (`scope:"turn"`, the default, matching the SDK `turn.abort` default and
@@ -2976,6 +3033,12 @@ export class AcpAgent implements Agent {
 		// subagents and background tasks stopped opts in with
 		// `_meta.gjc.abortScope: "owned"` (or `GJC_ACP_ABORT_SCOPE=owned`).
 		const scope = resolveAcpAbortScope(params._meta, process.env);
+		// The current turn is a model-free builtin answered locally: settling its reservation
+		// above cancels it, and the host has no turn to abort.
+		if (localCommand && scope === "turn") {
+			record.cancelRequested = false;
+			return;
+		}
 		const waiter = record.activePrompt;
 		const waiterWasUnacknowledged = waiter !== undefined && !waiter.acknowledged;
 		const waiterWasBeforeActivity = waiter !== undefined && !waiter.observedTurnActivity;
@@ -3051,9 +3114,11 @@ export class AcpAgent implements Agent {
 				// publication is advisory and must never gate the settlement above.
 				void this.#publishPromptPhaseIdle(params.sessionId, record.adapter);
 			} else {
+				if (waiter && record.activePrompt === waiter && waiter.terminal && !waiter.settled)
+					this.#settlePrompt(params.sessionId, record, waiter);
 				// The acknowledgement proves the run was aborted, not that its terminal was
 				// published. Arm the bounded settlement so the turn cannot outlive the cancel.
-				this.#scheduleCancelSettlement(params.sessionId, record);
+				else this.#scheduleCancelSettlement(params.sessionId, record);
 			}
 			waiter?.cancelAttemptResolve?.(true);
 		} catch (error) {
@@ -3069,6 +3134,9 @@ export class AcpAgent implements Agent {
 				!waiter.settled
 			) {
 				if (waiter.terminalReserved) {
+					await record.frameTail;
+					if (record.activePrompt === waiter && waiter.terminal && !waiter.settled)
+						this.#settlePrompt(params.sessionId, record, waiter);
 					waiter.cancelAttemptResolve?.(true);
 					return;
 				}
@@ -3124,6 +3192,9 @@ export class AcpAgent implements Agent {
 				waiter.cancelAttempt = undefined;
 				waiter.cancelAttemptResolve = undefined;
 			}
+			const cancelWaveSettled = !waiter || waiter.cancelAcknowledged || (waiter.pendingCancelAttempts ?? 0) <= 1;
+			if (cancelWaveSettled && waiter && record.activePrompt === waiter && waiter.terminal && !waiter.settled)
+				this.#settlePrompt(params.sessionId, record, waiter);
 			throw cancellationError;
 		} finally {
 			if (waiter) {
@@ -4885,7 +4956,18 @@ export class AcpAgent implements Agent {
 			// Failure diagnostics are useful but advisory. Settle before any mapped
 			// session update can await a backpressured client transport; otherwise an
 			// already-decided failure can still lose to the inactivity watchdog.
-			this.#settlePrompt(id, record, activePrompt);
+			// A terminal that races an in-flight cancel must not settle the public prompt before
+			// the cancel request proves its outcome. Otherwise a follow-up prompt can be admitted
+			// between the stale terminal settlement and the abort acknowledgement, leaving the
+			// cancelled background request reported as `end_turn`.
+			const cancelSettlementPending =
+				activePrompt.cancelAttempt !== undefined &&
+				!activePrompt.cancelAcknowledged &&
+				record.statusRecovery !== activePrompt &&
+				!this.#ownsUncertainAbort(record, activePrompt);
+			if (!cancelSettlementPending) {
+				this.#settlePrompt(id, record, activePrompt);
+			}
 		}
 		if (!isTerminal && derivedCorrelation === undefined) return;
 		if (!isTerminal && hasCorrelation(correlation)) {
@@ -5274,7 +5356,9 @@ export class AcpAgent implements Agent {
 		const { outcome } = waiter.terminal;
 		this.#rememberSettledPromptCorrelation(id, record, waiter.correlation);
 		if (outcome.kind === "stopped") {
-			waiter.resolve({ stopReason: outcome.reason });
+			// Once the SDK has acknowledged a client cancel, the cancellation owns the
+			// turn even if a stale terminal frame races in with another stopped reason.
+			waiter.resolve({ stopReason: waiter.cancelAcknowledged ? "cancelled" : outcome.reason });
 			return;
 		}
 		// `phase` is the host's own claim, and a host that omits it leaves `terminalOutcome`

package/src/modes/components/custom-editor.ts

@@ -1,6 +1,7 @@
 import { Editor, type KeyId, matchesKey, parseKittySequence } from "@gajae-code/tui";
 import { BracketedPasteHandler } from "@gajae-code/tui/bracketed-paste";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
+import { macosOptionChordForComposedText } from "../utils/macos-option-forwarding";
 
 type ConfigurableEditorAction = Extract<
 	AppKeybinding,
@@ -116,6 +117,12 @@ export class CustomEditor extends Editor {
 	onQueue?: () => void;
 	/** Called when Caps Lock is pressed. */
 	onCapsLock?: () => void;
+	/**
+	 * Called when typed text is what macOS composes for a bound Option chord
+	 * (for example `œ` for a bound `alt+q`), meaning the terminal sent Option as
+	 * text. The text is still inserted; the callback only explains the miss.
+	 */
+	onUnforwardedOptionChord?: (key: KeyId, text: string) => void;
 	/** Called when PageUp/PageDown should scroll the transcript viewport instead of prompt history. */
 	onViewportPageScroll?: (direction: -1 | 1) => void;
 	/** Called before regular composer input should return the transcript viewport to the live bottom. */
@@ -473,6 +480,13 @@ export class CustomEditor extends Editor {
 			}
 		}
 
+		if (this.onUnforwardedOptionChord) {
+			const optionKey = macosOptionChordForComposedText(data);
+			if (optionKey && (this.hasActionKey(optionKey) || this.#customKeyHandlers.has(optionKey))) {
+				this.onUnforwardedOptionChord(optionKey, data);
+			}
+		}
+
 		// Pass to parent for normal handling.
 		super.handleInput(data);
 	}