@gajae-code/coding-agent 0.16.4 → 0.16.6

package/src/lsp/config.ts

@@ -336,14 +336,21 @@ export function resolveCommand(command: string, cwd: string): string | null {
 	return piUtils.$which(command);
 }
 
-/** Resolve an LSP executable without consulting project-controlled bin directories. */
+/**
+ * Resolve an LSP executable without consulting project-controlled bin directories.
+ *
+ * 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 {
 	if (!path.isAbsolute(command) && (command.includes("/") || command.includes("\\"))) return null;
 	const discovered = path.isAbsolute(command) ? command : piUtils.$which(command);
 	if (!discovered) return null;
 	if (isProjectControlledPath(discovered, cwd)) return null;
-	const canonical = canonicalExistingPath(discovered);
-	return canonical;
+	if (!canonicalExistingPath(discovered)) return null;
+	return discovered;
 }
 
 interface ConfigSource {

package/src/lsp/index.ts

@@ -1160,7 +1160,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			const serverStatus =
 				servers.length > 0
-					? `Active language servers: ${servers.join(", ")}`
+					? `Configured language servers: ${servers.join(", ")}`
 					: "No language servers configured for this project";
 
 			const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;

package/src/lsp/path-trust.ts

@@ -59,29 +59,84 @@ function findProjectTrustRoot(start: string, stopPaths: ReadonlySet<string>): st
 	}
 }
 
+function isProjectMarkerRoot(root: string): boolean {
+	return fs.existsSync(path.join(root, ".git")) || isDirectory(path.join(root, CONFIG_DIR_NAME));
+}
+
+/**
+ * Spellings of `candidate` that differ only in how HOME is named: the path as
+ * given, plus the same path with any ancestor that is HOME under another name
+ * replaced by canonical HOME. The suffix beneath HOME is kept as spelled, and an
+ * alias that lives inside a project (`repo/home-link -> HOME`) is project
+ * content, not a HOME spelling, so it is never expanded.
+ */
+function candidateSpellings(candidate: string, canonicalHome: string, projectRoot: string | undefined): string[] {
+	const resolved = path.resolve(candidate);
+	const spellings = [resolved];
+	const normalizedHome = normalizePathForComparison(canonicalHome);
+	let current = path.dirname(resolved);
+	for (;;) {
+		if (
+			normalizePathForComparison(current) !== normalizedHome &&
+			(projectRoot === undefined || !pathIsLexicallyWithin(projectRoot, current)) &&
+			normalizePathForComparison(canonicalPath(current)) === normalizedHome
+		) {
+			spellings.push(path.join(canonicalHome, path.relative(current, resolved)));
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return spellings;
+		current = parent;
+	}
+}
+
 export function isProjectControlledPath(candidate: string, cwd: string): boolean {
 	const home = os.homedir();
-	const stopPaths = new Set([path.resolve(home), canonicalPath(home)].map(normalizePathForComparison));
+	const canonicalHome = canonicalPath(home);
+	const stopPaths = new Set([path.resolve(home), canonicalHome].map(normalizePathForComparison));
 	const lexicalTrustRoot = findProjectTrustRoot(cwd, stopPaths);
-	const candidateIsHomeScoped = pathIsLexicallyWithin(home, candidate) || pathIsWithin(home, candidate);
-	if (
-		lexicalTrustRoot !== undefined &&
-		pathIsLexicallyWithin(lexicalTrustRoot, candidate) &&
-		(!candidateIsHomeScoped || pathIsLexicallyWithin(home, lexicalTrustRoot))
-	)
-		return true;
+	// A trust root outside HOME must not claim user executables inside HOME
+	// (e.g. ~/.gjc/bin); a root under HOME still owns what it contains. Each check
+	// judges home scope on the same view of the path it inspects, without
+	// dereferencing the candidate's final component: mixing views let a project
+	// link into HOME, or a HOME link into the project, escape rejection. HOME may
+	// be spelled lexically or canonically on either side, so the lexical check
+	// runs over every HOME-alias spelling of both the candidate and the root.
+	if (lexicalTrustRoot !== undefined) {
+		const trustRootIsHomeScoped = pathIsWithin(canonicalHome, lexicalTrustRoot);
+		// A root under HOME may legitimately be reached through a HOME alias, and a
+		// bare fallback root (no project marker) owns nothing on its own; a real
+		// project root outside HOME owns every alias directory it contains.
+		const aliasBoundary =
+			!trustRootIsHomeScoped && isProjectMarkerRoot(lexicalTrustRoot) ? lexicalTrustRoot : undefined;
+		const rootSpellings = candidateSpellings(lexicalTrustRoot, canonicalHome, undefined);
+		const spellings = candidateSpellings(candidate, canonicalHome, aliasBoundary);
+		// Every spelling names the same location, so home scope is a property of
+		// the location: one spelling under HOME makes all of them HOME-scoped.
+		const candidateIsHomeScoped = spellings.some(
+			spelling => pathIsLexicallyWithin(home, spelling) || pathIsLexicallyWithin(canonicalHome, spelling),
+		);
+		if (
+			(!candidateIsHomeScoped || trustRootIsHomeScoped) &&
+			spellings.some(spelling => rootSpellings.some(root => pathIsLexicallyWithin(root, spelling)))
+		) {
+			return true;
+		}
+	}
 
+	const canonicalCandidate = canonicalPath(candidate);
+	const canonicalCandidateParent = canonicalParentPath(candidate);
+	const parentIsHomeScoped = pathIsLexicallyWithin(canonicalHome, canonicalCandidateParent);
+	const targetIsHomeScoped = pathIsWithin(canonicalHome, canonicalCandidate);
 	const canonicalTrustRoots = new Set<string>();
 	if (lexicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(lexicalTrustRoot));
 	const canonicalTrustRoot = findProjectTrustRoot(canonicalPath(cwd), stopPaths);
 	if (canonicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(canonicalTrustRoot));
 	for (const trustRoot of canonicalTrustRoots) {
-		if (
-			(pathIsLexicallyWithin(trustRoot, canonicalParentPath(candidate)) ||
-				pathIsWithin(trustRoot, canonicalPath(candidate))) &&
-			(!candidateIsHomeScoped || pathIsLexicallyWithin(home, trustRoot) || pathIsWithin(home, trustRoot))
-		)
-			return true;
+		const trustRootIsHomeScoped = pathIsLexicallyWithin(canonicalHome, trustRoot);
+		const parentOwned =
+			pathIsLexicallyWithin(trustRoot, canonicalCandidateParent) && (!parentIsHomeScoped || trustRootIsHomeScoped);
+		const targetOwned = pathIsWithin(trustRoot, canonicalCandidate) && (!targetIsHomeScoped || trustRootIsHomeScoped);
+		if (parentOwned || targetOwned) return true;
 	}
 	return false;
 }

package/src/main.ts

@@ -68,6 +68,7 @@ import {
 import { processIncarnation } from "./sdk/broker/process-incarnation";
 import { newMasterAttestationEpoch, resolveSessionLocator, SessionIndex } from "./sdk/broker/session-index";
 import type { AgentSession } from "./session/agent-session";
+import { ManagedAppendIdentityMismatchError } from "./session/internal/managed-session-storage";
 import { SessionMigrationBusyError } from "./session/internal/session-open-errors";
 import {
 	type ResumeSessionIdentity,
@@ -551,7 +552,11 @@ export async function applyStartupModelProfiles(args: StartupModelProfileArgs):
 
 async function exitForStartupModelProfileError(args: StartupModelProfileArgs, error: unknown): Promise<never> {
 	const message = error instanceof Error ? error.message : String(error);
-	process.stderr.write(`${chalk.red(`Error: ${message}`)}\n`);
+	process.stderr.write(
+		error instanceof ManagedAppendIdentityMismatchError
+			? `${error.operatorMessage}\n`
+			: `${chalk.red(`Error: ${message}`)}\n`,
+	);
 	await args.session.dispose();
 	process.exit(1);
 }

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

@@ -101,6 +101,16 @@ const MAX_PROMPT_FRAME_BYTES = 256 * 1024;
  * envelope. A canonical-length UUID keeps the measurement equal to the real frame.
  */
 const PROMPT_FRAME_ID_PLACEHOLDER = "00000000-0000-4000-8000-000000000000";
+/**
+ * Readiness budget every ACP session launch requests, independent of MCP.
+ *
+ * Host cold start costs the same whether or not the client declared MCP servers,
+ * so leaving the MCP-less path on the broker's 10s default made it the only ACP
+ * launch that fails under ordinary concurrency: a second host starting beside the
+ * first measurably crosses that deadline, and the broker then reports the launch
+ * as `terminal_uncertain`, which an external client surfaces as a dead provider.
+ */
+const ACP_SESSION_READINESS_TIMEOUT_MS = ACP_MCP_LIFECYCLE_TIMEOUT_MS;
 
 type JsonObject = Record<string, unknown>;
 interface PromptWaiter {
@@ -1362,7 +1372,8 @@ export class AcpAgent implements Agent {
 				cwd: params.cwd,
 				target: { path: params.cwd },
 				...(this.#startupOptions?.modelPreset ? { modelPreset: this.#startupOptions.modelPreset } : {}),
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,
@@ -1418,7 +1429,8 @@ export class AcpAgent implements Agent {
 				sourceSessionId: params.sessionId,
 				sourceSessionPath: source,
 				target: { path: params.cwd },
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,
@@ -2268,7 +2280,8 @@ export class AcpAgent implements Agent {
 				sessionId: id,
 				sessionPath: saved,
 				target: { path: cwd },
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,

package/src/modes/components/bash-execution.ts

@@ -43,6 +43,7 @@ export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
 	#status: ExecutionStatus = "running";
 	#exitCode: number | undefined = undefined;
+	#signal: string | undefined = undefined;
 	#loader: Loader;
 	#truncation?: TruncationMeta;
 	#expanded = false;
@@ -127,9 +128,10 @@ export class BashExecutionComponent extends Container {
 	setComplete(
 		exitCode: number | undefined,
 		cancelled: boolean,
-		options?: { output?: string; truncation?: TruncationMeta },
+		options?: { output?: string; signal?: string; truncation?: TruncationMeta },
 	): void {
 		this.#exitCode = exitCode;
+		this.#signal = options?.signal;
 		this.#status = resolveExecutionStatus(exitCode, cancelled);
 		this.#truncation = options?.truncation;
 		if (options?.output !== undefined) {
@@ -215,6 +217,7 @@ export class BashExecutionComponent extends Container {
 			const footer = buildStatusFooter({
 				status: this.#status,
 				exitCode: this.#exitCode,
+				signal: this.#signal,
 				truncation: this.#truncation,
 				hiddenLineCount,
 				suppressHiddenCount: hasSixelOutput && !fallbackActive,

package/src/modes/components/execution-shared.ts

@@ -68,6 +68,7 @@ export function createCollapsedPreview(previewText: string, previewLines: number
 export function buildStatusFooter(opts: {
 	status: ExecutionStatus;
 	exitCode: number | undefined;
+	signal?: string;
 	truncation: TruncationMeta | undefined;
 	hiddenLineCount: number;
 	/** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */
@@ -81,7 +82,9 @@ export function buildStatusFooter(opts: {
 	if (opts.status === "cancelled") {
 		parts.push(theme.fg("warning", "(cancelled)"));
 	} else if (opts.status === "error") {
-		parts.push(theme.fg("error", `(exit ${opts.exitCode})`));
+		parts.push(
+			theme.fg("error", opts.signal ? `(${opts.signal}, exit ${opts.exitCode})` : `(exit ${opts.exitCode})`),
+		);
 	}
 	if (opts.truncation) {
 		parts.push(theme.fg("warning", formatTruncationMetaNotice(opts.truncation)));

package/src/modes/components/session-observer-overlay.ts

@@ -272,7 +272,7 @@ export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 		this.#cache = {
 			...cache,
 			completeOffset: cache.completeOffset + complete.bytes.length,
-			prefixDigest: digest(Buffer.concat([snapshot.prefix, complete.bytes])),
+			prefixDigest: crypto.createHash("sha256").update(snapshot.prefix).update(complete.bytes).digest("hex"),
 			entries,
 			model: parsed.model ?? cache.model,
 			...projection.state,

package/src/modes/components/tool-status-header.ts

@@ -854,6 +854,8 @@ export class StatusLineComponent implements Component {
 		// treats a null value as hidden, so gating here is behavior-identical.
 		const prSegmentActive =
 			effectiveSettings.leftSegments.includes("pr") || effectiveSettings.rightSegments.includes("pr");
+		const gitSegmentActive =
+			effectiveSettings.leftSegments.includes("git") || effectiveSettings.rightSegments.includes("git");
 		const commandSegmentActive =
 			effectiveSettings.leftSegments.includes("command") || effectiveSettings.rightSegments.includes("command");
 		const commandOptions = commandSegmentActive ? this.#trustedCommandOptions() : undefined;
@@ -883,7 +885,7 @@ export class StatusLineComponent implements Component {
 			sessionStartTime: this.#sessionStartTime,
 			git: {
 				branch: this.#getCurrentBranch(),
-				status: this.#getGitStatus(),
+				status: gitSegmentActive ? this.#getGitStatus() : null,
 				pr: prSegmentActive ? (previewOnly ? (this.#cachedPr ?? null) : this.#lookupPr()) : null,
 			},
 			usage: this.#cachedUsage,

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

@@ -1233,6 +1233,7 @@ export class CommandController {
 				const meta = outputMeta().truncationFromSummary(result, { direction: "tail" }).get();
 				this.ctx.bashComponent.setComplete(result.exitCode, result.cancelled, {
 					output: result.output,
+					signal: result.signal,
 					truncation: meta?.truncation,
 				});
 			}

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

@@ -16,6 +16,7 @@ import { ToolExecutionComponent, type ToolExecutionHandle } from "../../modes/co
 import { TtsrNotificationComponent } from "../../modes/components/ttsr-notification";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import {
+	clearInteractiveActivityIndicator,
 	type InteractiveModeContext,
 	stopInteractiveActivityIndicator,
 	syncInteractiveActivityIndicator,
@@ -1104,7 +1105,7 @@ export class EventController {
 		this.ctx.editor.onEscape = () => {
 			this.ctx.session.abortCompaction();
 		};
-		stopInteractiveActivityIndicator(this.ctx, { restoreBackground: false, foregroundSettled: true });
+		clearInteractiveActivityIndicator(this.ctx);
 		const reasonText =
 			event.reason === "overflow" ? "Context overflow detected, " : event.reason === "idle" ? "Idle " : "";
 		const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
@@ -1205,7 +1206,7 @@ export class EventController {
 				this.ctx.session.abortRetry();
 			}
 		};
-		stopInteractiveActivityIndicator(this.ctx, { restoreBackground: false, foregroundSettled: true });
+		clearInteractiveActivityIndicator(this.ctx);
 		// Stop any prior retry loader/timer before installing a new one.
 		this.ctx.retryLoader?.stop();
 		this.#clearRetryCountdown();

package/src/modes/controllers/extension-ui-controller.ts

@@ -292,6 +292,7 @@ export class ExtensionUiController {
 				const result = await session.executeBash(input.cmd, undefined, { excludeFromContext: true });
 				return {
 					exitCode: result.exitCode,
+					signal: result.signal,
 					cancelled: result.cancelled,
 					output: result.output,
 					truncated: result.truncated,

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

@@ -273,16 +273,19 @@ export class InputController {
 
 	#syncTranscriptTurnPosition(): readonly string[] {
 		const anchorIds = getUserMessageViewportAnchorIds(this.ctx.session.messages);
+		const previousAnchorIds = new Set(this.#transcriptTurnAnchorIds);
 		if (
 			anchorIds.length !== this.#transcriptTurnAnchorIds.length ||
-			anchorIds.some(id => !this.#transcriptTurnAnchorIds.includes(id))
+			anchorIds.some(id => !previousAnchorIds.has(id))
 		) {
 			const hadAnchors = this.#transcriptTurnAnchorIds.length > 0;
 			const currentAnchorId = this.#transcriptTurnAnchorIds[this.#transcriptTurnPosition];
-			const retainedAnchorIds = this.#transcriptTurnAnchorIds.filter(id => anchorIds.includes(id));
+			const incomingAnchorIds = new Set(anchorIds);
+			const retainedAnchorIds = this.#transcriptTurnAnchorIds.filter(id => incomingAnchorIds.has(id));
+			const retainedAnchorIdSet = new Set(retainedAnchorIds);
 			this.#transcriptTurnAnchorIds = [
 				...retainedAnchorIds,
-				...anchorIds.filter(id => !retainedAnchorIds.includes(id)),
+				...anchorIds.filter(id => !retainedAnchorIdSet.has(id)),
 			];
 			const currentPosition = currentAnchorId ? this.#transcriptTurnAnchorIds.indexOf(currentAnchorId) : -1;
 			this.#transcriptTurnPosition =

package/src/modes/interactive-mode.ts

@@ -1700,7 +1700,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			}
 		}
 		this.#stopListeners.clear();
-		this.#stopLoadingAnimation();
+		this.clearLoadingAnimation();
 		this.#suspendedActivityIndicator = undefined;
 		this.#petProtocolUnsubscribe?.();
 		this.#petProtocolUnsubscribe = undefined;
@@ -1996,7 +1996,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		return tallyBackgroundActivity(this.session.getAsyncJobSnapshot()?.running ?? []);
 	}
 
-	#stopLoadingAnimation(): void {
+	/** Clear the status display without settling the foreground run during maintenance/retry. */
+	clearLoadingAnimation(): void {
 		this.loadingAnimation?.stop();
 		this.loadingAnimation = undefined;
 		this.statusContainer.clear();
@@ -2007,7 +2008,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		const foregroundActive = this.#foregroundActivity || (!this.#foregroundTurnSettled && this.session.isStreaming);
 		if (!this.isInitialized && !foregroundActive) {
-			this.#stopLoadingAnimation();
+			this.clearLoadingAnimation();
 			return;
 		}
 		const message = resolveActivityIndicatorMessage(
@@ -2016,7 +2017,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#pendingWorkingMessage ?? this.#defaultWorkingMessage,
 		);
 		if (!message) {
-			this.#stopLoadingAnimation();
+			this.clearLoadingAnimation();
 			return;
 		}
 		if (!this.loadingAnimation) {
@@ -2047,7 +2048,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#foregroundActivity = false;
 		if (options?.foregroundSettled) this.#foregroundTurnSettled = true;
 		if (options?.restoreBackground === false) {
-			this.#stopLoadingAnimation();
+			this.clearLoadingAnimation();
 			return;
 		}
 		this.syncActivityIndicator();

package/src/modes/print-mode.ts

@@ -10,6 +10,7 @@ import { type AssistantMessage, type ImageContent, isContextOverflow } from "@ga
 import { isKnownSinkPeerClosedError, logger, sanitizeText } from "@gajae-code/utils";
 import { loadSlashCommands } from "../extensibility/slash-commands";
 import type { AgentSession } from "../session/agent-session";
+import { ManagedAppendIdentityMismatchError } from "../session/internal/managed-session-storage";
 import { isSilentAbort } from "../session/messages";
 import { resolveProviderSafetyStopHint } from "../session/provider-safety-stop-hint";
 import { executeLocalHeadlessBuiltinSlashCommand } from "../slash-commands/builtin-registry";
@@ -388,7 +389,10 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		// Observe callback and stream errors from every preceding print-mode write.
 		await stdout.flush();
 	} catch (error) {
-		failures.push(error);
+		if (error instanceof ManagedAppendIdentityMismatchError) {
+			process.exitCode = 1;
+			await writeStderrAndQuiesce(`${error.operatorMessage}\n`);
+		} else failures.push(error);
 	} finally {
 		// The JSON subscriber remains live while disposal emits its final events.
 		try {

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

@@ -89,23 +89,37 @@ function getSlashCommandPriority(command: SlashCommand | undefined, item: Autoco
 	return ADVANCED_SLASH_COMMAND_PRIORITIES.get(item.value) ?? 0;
 }
 
+interface SlashCommandMetadata {
+	command: SlashCommand;
+	index: number;
+	lowerName: string;
+	normalizedName: string;
+	normalizedDescription: string | undefined;
+}
+
+interface SkillCommandMetadata {
+	command: SlashCommand;
+	lowerSkillName: string;
+	searchTargets: string[];
+	collisionSearchTargets: string[];
+}
+
 function sortSlashCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
-	commands: SlashCommand[],
+	commandMetadata: ReadonlyMap<string, SlashCommandMetadata>,
 ): { items: AutocompleteItem[]; prefix: string } | null {
 	if (!suggestions) return null;
 	const query = suggestions.prefix.slice(1).toLowerCase();
 	const normalizedQuery = normalizeFuzzyText(query);
-	const commandIndexes = new Map(commands.map((command, index) => [command.name, index]));
-	const commandByName = new Map(commands.map(command => [command.name, command]));
 	const items = suggestions.items
 		.map((item, index) => {
-			const command = commandByName.get(item.value);
-			const commandIndex = commandIndexes.get(item.value) ?? index;
-			const lowerName = item.value.toLowerCase();
-			const lowerDesc = command?.description?.toLowerCase() ?? item.description?.toLowerCase() ?? "";
-			const normalizedName = normalizeFuzzyText(item.value);
-			const normalizedDesc = normalizeFuzzyText(lowerDesc);
+			const metadata = commandMetadata.get(item.value);
+			const command = metadata?.command;
+			const commandIndex = metadata?.index ?? index;
+			const lowerName = metadata?.lowerName ?? item.value.toLowerCase();
+			const normalizedName = metadata?.normalizedName ?? normalizeFuzzyText(item.value);
+			const normalizedDesc =
+				metadata?.normalizedDescription ?? normalizeFuzzyText(item.description?.toLowerCase() ?? "");
 			const nameScore = autocompleteFuzzyMatch(normalizedQuery, normalizedName)
 				? autocompleteFuzzyScore(normalizedQuery, normalizedName)
 				: 0;
@@ -180,7 +194,8 @@ function isSlashTokenInsideInlineCodeSpan(
 export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
-	#commands: SlashCommand[];
+	#commandMetadata = new Map<string, SlashCommandMetadata>();
+	#skillCommandMetadata: SkillCommandMetadata[] = [];
 	#getPromptSuggestion: (() => string | null) | undefined;
 
 	constructor(
@@ -191,7 +206,28 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	) {
 		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath);
 		this.#actions = actions;
-		this.#commands = commands;
+		for (const [index, command] of commands.entries()) {
+			this.#commandMetadata.set(command.name, {
+				command,
+				index,
+				lowerName: command.name.toLowerCase(),
+				normalizedName: normalizeFuzzyText(command.name),
+				normalizedDescription:
+					command.description === undefined ? undefined : normalizeFuzzyText(command.description.toLowerCase()),
+			});
+			if (command.name.startsWith("skill:")) {
+				const skillName = command.name.slice("skill:".length);
+				const name = normalizeFuzzyText(command.name);
+				const alias = normalizeFuzzyText(`skill-${skillName}`);
+				const description = normalizeFuzzyText(command.description ?? "");
+				this.#skillCommandMetadata.push({
+					command,
+					lowerSkillName: skillName.toLowerCase(),
+					searchTargets: [name, alias, normalizeFuzzyText(skillName), description],
+					collisionSearchTargets: [name, alias, description],
+				});
+			}
+		}
 		this.#getPromptSuggestion = getPromptSuggestion;
 	}
 
@@ -244,7 +280,7 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			});
 			return sortSlashCommandSuggestions(
 				mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
-				this.#commands,
+				this.#commandMetadata,
 			);
 		}
 		if (rawSlashPrefix && slashTokenInsideCode) {
@@ -334,7 +370,7 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor, { includeEmpty: false });
 		return sortSlashCommandSuggestions(
 			mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
-			this.#commands,
+			this.#commandMetadata,
 		);
 	}
 	trySyncInlineReplace(textBeforeCursor: string): { replaceLen: number; insert: string } | null {
@@ -354,20 +390,11 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query,
 		);
 		if (query.length > 0 && normalizedQuery.length === 0) return null;
-		const exactNonSkillCommand = this.#commands.some(
-			command => command.name === query && !command.name.startsWith("skill:"),
-		);
-		const items = this.#commands
-			.filter(command => command.name.startsWith("skill:"))
-			.map(command => {
-				const skillName = command.name.slice("skill:".length);
-				if (exactNonSkillCommand && query === skillName.toLowerCase()) return null;
-				const searchTargets = [
-					command.name,
-					`skill-${skillName}`,
-					...(exactNonSkillCommand ? [] : [skillName]),
-					command.description ?? "",
-				].map(target => normalizeFuzzyText(target));
+		const exactNonSkillCommand = this.#commandMetadata.has(query) && !query.startsWith("skill:");
+		const items = this.#skillCommandMetadata
+			.map(({ command, lowerSkillName, searchTargets: allSearchTargets, collisionSearchTargets }) => {
+				if (exactNonSkillCommand && query === lowerSkillName) return null;
+				const searchTargets = exactNonSkillCommand ? collisionSearchTargets : allSearchTargets;
 				if (
 					!searchTargets.some(
 						target => autocompleteFuzzyMatch(normalizedQuery, target) || target.includes(normalizedQuery),

package/src/modes/runtime-init.ts

@@ -201,6 +201,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			},
 			getJobs: () => session.getAsyncJobSnapshot(),
 			onJobFold: listener => session.onJobFold(listener),
+			onSessionEvent: listener => session.subscribe(listener),
 			setSdkPermissionProvider: provider => session.setSdkPermissionProvider(provider),
 			setSdkClientBridge: bridge => session.setClientBridge(bridge),
 			sdkControl: async (operation, input) => {
@@ -325,6 +326,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 						const result = await session.executeBash(input.cmd, undefined, { excludeFromContext: true });
 						return {
 							exitCode: result.exitCode,
+							signal: result.signal,
 							cancelled: result.cancelled,
 							output: result.output,
 							truncated: result.truncated,

package/src/modes/types.ts

@@ -74,6 +74,20 @@ export type ActivityIndicatorStopOptions = Readonly<{
 	foregroundSettled?: boolean;
 }>;
 
+export function clearInteractiveActivityIndicator(ctx: {
+	loadingAnimation?: Loader;
+	statusContainer?: PartialActivityStatusContainer;
+	clearLoadingAnimation?: () => void;
+}): void {
+	if (ctx.clearLoadingAnimation) {
+		ctx.clearLoadingAnimation();
+		return;
+	}
+	ctx.loadingAnimation?.stop();
+	ctx.loadingAnimation = undefined;
+	ctx.statusContainer?.clear?.();
+}
+
 export function stopInteractiveActivityIndicator(
 	ctx: {
 		loadingAnimation?: Loader;
@@ -86,9 +100,7 @@ export function stopInteractiveActivityIndicator(
 		ctx.stopLoadingAnimation(options);
 		return;
 	}
-	ctx.loadingAnimation?.stop();
-	ctx.loadingAnimation = undefined;
-	ctx.statusContainer?.clear?.();
+	clearInteractiveActivityIndicator(ctx);
 }
 
 export function clearInteractiveActivityLoaders(
@@ -285,6 +297,7 @@ export interface InteractiveModeContext {
 	setWorkingMessage(message?: string): void;
 	applyPendingWorkingMessage(): void;
 	ensureLoadingAnimation(): void;
+	clearLoadingAnimation(): void;
 	syncActivityIndicator(): void;
 	suspendActivityIndicator(): () => void;
 	stopLoadingAnimation(options?: ActivityIndicatorStopOptions): void;

package/src/modes/utils/ui-helpers.ts

@@ -530,6 +530,7 @@ export class UiHelpers {
 					component.appendOutput(message.output);
 				}
 				component.setComplete(message.exitCode, message.cancelled, {
+					signal: message.signal,
 					truncation: message.meta?.truncation,
 				});
 				addChatChild(this.ctx, component);

package/src/prompts/tools/subagent.md

@@ -15,6 +15,7 @@ Inspect selected subagents by `ids`; omit `ids` to inspect current running subag
 ## `action: "await"`
 Wait for selected subagents by `ids`; omit `ids` to wait for current running subagents.
 - Always set `timeout_ms` when the result is not immediately required forever.
+- `heartbeat_ms` accepts integer intervals from 100 to 60,000 milliseconds (for example, 10,000 for ten seconds); `0` disables heartbeat updates and omission retains the 500 ms default. Terminal completion is event-driven, not delayed until the next heartbeat.
 - Await timeout only bounds this tool call's wait; it does not stop the subagent and is not a failure reason.
 - On timeout, inspect progress and keep doing independent work. Never cancel just because an await timed out; cancel only if the subagent has actually failed, gone off-track, or become unrecoverably wrong.
 - Completed results are receipt-first by default: bounded preview plus `agent://<id>` output ref when available, not full retained output.