@gajae-code/coding-agent 0.9.4 → 0.9.5

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [0.9.5] - 2026-07-09
+### Fixed
+
+- ACP permission prompts now honor `clientCapabilities._meta.gjc.permissionHandling` and the `GJC_ACP_PERMISSION_MODE` fallback, so `auto` and `always-allow` no longer emit `session/request_permission` calls while invalid values fail safely to `prompt`.
+- Model selector batch assignments ("Set for all role agents" / "Set for all targets") now open the reasoning-effort menu whenever any batch target requires an explicit choice (e.g. Anthropic reasoning models like `claude-fable-5`), and the chosen effort plus the full batch survive the menu. Previously the menu never appeared for Anthropic models (silently persisting `:off` selectors for every role agent), and for OpenAI/Codex models picking an effort collapsed the batch to a DEFAULT-only assignment.
+### Added
+
+- ACP clients now receive GJC automatic-compaction start/end state through additive `session_info_update` metadata, including the compaction action, trigger, retry/abort/error outcome, and busy-to-idle phase transitions.
+
 ## [0.9.4] - 2026-07-09
 ### Fixed
 

package/dist/types/modes/acp/acp-event-mapper.d.ts

@@ -16,6 +16,8 @@ interface AcpEventMapperOptions {
      * before emitting `ToolCallLocation` entries.
      */
     cwd?: string;
+    /** Phase to expose after compaction ends. Prompt-bound compaction resumes responding; idle maintenance returns idle. */
+    compactionEndPhase?: "responding" | "idle";
 }
 export declare function mapToolKind(toolName: string): ToolKind;
 export declare function mapAgentWireEventPayloadToAcpSessionUpdates(payload: AgentWireEventPayload, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.9.4",
+	"version": "0.9.5",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -49,12 +49,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.9.4",
-		"@gajae-code/agent-core": "0.9.4",
-		"@gajae-code/ai": "0.9.4",
-		"@gajae-code/natives": "0.9.4",
-		"@gajae-code/tui": "0.9.4",
-		"@gajae-code/utils": "0.9.4",
+		"@gajae-code/stats": "0.9.5",
+		"@gajae-code/agent-core": "0.9.5",
+		"@gajae-code/ai": "0.9.5",
+		"@gajae-code/natives": "0.9.5",
+		"@gajae-code/tui": "0.9.5",
+		"@gajae-code/utils": "0.9.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

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

@@ -152,8 +152,8 @@ type ManagedSessionRecord = {
 	liveMessageProgress: { textEmitted: boolean; thoughtEmitted: boolean } | undefined;
 	toolArgsById: Map<string, unknown>;
 	extensionsConfigured: boolean;
-	// Installed inside `#scheduleBootstrapUpdates` (post-race-guard); released
-	// in `#disposeSessionRecord`. Lives independent of any prompt turn.
+	// Installed after the bootstrap race guard or eagerly when the client starts a prompt;
+	// released in `#disposeSessionRecord`. Lives independent of any prompt turn.
 	lifetimeUnsubscribe: (() => void) | undefined;
 };
 
@@ -619,6 +619,7 @@ export class AcpAgent implements Agent {
 				promise: pendingPrompt.promise,
 			};
 
+			this.#ensureLifetimeSubscription(record);
 			record.promptTurn.unsubscribe = record.session.subscribe(event => {
 				void this.#handlePromptEvent(record, event);
 			});
@@ -831,6 +832,7 @@ export class AcpAgent implements Agent {
 		}
 		promptTurn.cancelRequested = true;
 		promptTurn.unsubscribe?.();
+		void this.#emitCancelledPromptIdleUpdate(record);
 		const cleanup = this.#runCancelCleanup(record, promptTurn);
 		promptTurn.cleanup = cleanup;
 		this.#finishPrompt(record, {
@@ -1043,8 +1045,8 @@ export class AcpAgent implements Agent {
 	async #registerPreparedSession(session: AgentSession, mcpServers: McpServer[]): Promise<ManagedSessionRecord> {
 		const record = this.#createManagedSessionRecord(session);
 		session.setClientBridge(createAcpClientBridge(this.#connection, session.sessionId, this.#clientCapabilities));
-		// `record.lifetimeUnsubscribe` is installed in `#scheduleBootstrapUpdates`
-		// so it shares the bootstrap race guard — see that comment for why.
+		// The lifetime subscription normally follows the bootstrap race guard, but
+		// prompt() installs it eagerly once the client has demonstrated session ownership.
 		try {
 			await this.#configureExtensions(record);
 			await this.#configureMcpServers(record, mcpServers);
@@ -1070,7 +1072,38 @@ export class AcpAgent implements Agent {
 		};
 	}
 
+	#ensureLifetimeSubscription(record: ManagedSessionRecord): void {
+		if (record.lifetimeUnsubscribe) {
+			return;
+		}
+		record.lifetimeUnsubscribe = record.session.subscribe(event => {
+			void this.#handleLifetimeEvent(record, event);
+		});
+	}
+
 	async #handleLifetimeEvent(record: ManagedSessionRecord, event: AgentSessionEvent): Promise<void> {
+		if (event.type === "auto_compaction_start" || event.type === "auto_compaction_end") {
+			// Prompt-bound compaction is normally forwarded by #handlePromptEvent. The lifetime
+			// subscription covers idle maintenance and the end event after prompt cancellation.
+			const promptTurn = record.promptTurn;
+			if (
+				isPromptTurnInFlight(promptTurn) &&
+				(!promptTurn.cancelRequested || event.type === "auto_compaction_start")
+			) {
+				return;
+			}
+			for (const notification of mapAgentWireEventPayloadToAcpSessionUpdates(
+				toAgentWireEventPayload(event),
+				record.session.sessionId,
+				{
+					cwd: record.session.sessionManager.getCwd(),
+					compactionEndPhase: "idle",
+				},
+			)) {
+				await this.#connection.sessionUpdate(notification);
+			}
+			return;
+		}
 		if (event.type !== "thinking_level_changed") {
 			return;
 		}
@@ -1140,6 +1173,7 @@ export class AcpAgent implements Agent {
 				getMessageProgress: message => this.#getLiveMessageProgress(record, message),
 				getToolArgs: toolCallId => record.toolArgsById.get(toolCallId),
 				cwd: record.session.sessionManager.getCwd(),
+				compactionEndPhase: "responding",
 			},
 		)) {
 			await this.#connection.sessionUpdate(notification);
@@ -1551,13 +1585,10 @@ export class AcpAgent implements Agent {
 		// enough that the response future has scheduled before our timer fires
 		// on stdio-only transports.
 		//
-		// The session-lifetime subscription is installed inside the same timer
-		// so it shares this guard — without it, an extension's `session_start`
-		// handler (or any async work it schedules) calling `setThinkingLevel`
-		// would push a `config_option_update` for a session id the client
-		// hasn't been told about yet. The pre-bootstrap thinking level is
-		// reported in the response's `configOptions`, so deferring the
-		// notification loses no state.
+		// The session-lifetime subscription normally shares this guard so extension
+		// work cannot notify an unknown session id. prompt() may install it earlier:
+		// receipt of a prompt proves the client already owns the returned session id,
+		// and closes the cancellation window before this timer fires.
 		setTimeout(() => {
 			if (this.#connection.signal.aborted) {
 				return;
@@ -1566,11 +1597,7 @@ export class AcpAgent implements Agent {
 			if (!record) {
 				return;
 			}
-			if (!record.lifetimeUnsubscribe) {
-				record.lifetimeUnsubscribe = record.session.subscribe(event => {
-					void this.#handleLifetimeEvent(record, event);
-				});
-			}
+			this.#ensureLifetimeSubscription(record);
 			void this.#emitBootstrapUpdates(sessionId, record);
 		}, ACP_BOOTSTRAP_RACE_GUARD_MS);
 	}
@@ -1606,6 +1633,30 @@ export class AcpAgent implements Agent {
 		});
 	}
 
+	/** Ensure cancellation clears a previously emitted busy/compacting phase even if abort never produces an end event. */
+	async #emitCancelledPromptIdleUpdate(record: ManagedSessionRecord): Promise<void> {
+		if (this.#connection.signal.aborted) {
+			return;
+		}
+		try {
+			await this.#connection.sessionUpdate({
+				sessionId: record.session.sessionId,
+				update: {
+					sessionUpdate: "session_info_update",
+					title: record.session.sessionName,
+					updatedAt: new Date().toISOString(),
+					_meta: {
+						gjcPhase: "idle",
+						running: false,
+						gjcRunning: false,
+					},
+				},
+			});
+		} catch (error) {
+			logger.warn("Failed to emit cancelled ACP prompt idle update", { error });
+		}
+	}
+
 	/**
 	 * Reload plugin/registry state for an ACP session. Mirrors the interactive
 	 * `/reload-plugins` and `/move` flows: invalidates the plugin-roots cache,
@@ -1647,6 +1698,11 @@ export class AcpAgent implements Agent {
 				sessionUpdate: "session_info_update",
 				title: record.session.sessionName,
 				updatedAt: new Date().toISOString(),
+				_meta: {
+					gjcPhase: "idle",
+					running: false,
+					gjcRunning: false,
+				},
 			},
 		});
 	}

package/src/modes/acp/acp-client-bridge.ts

@@ -22,18 +22,38 @@ import type {
 	ClientBridgeTerminalHandle,
 } from "../../session/client-bridge";
 
+type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+
+const ACP_PERMISSION_MODE_ENV = "GJC_ACP_PERMISSION_MODE";
+
+function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
+	if (value === "auto" || value === "prompt" || value === "always-allow") return value;
+	return "prompt";
+}
+
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined): AcpPermissionMode {
+	const meta = clientCapabilities?._meta;
+	if (typeof meta === "object" && meta !== null) {
+		const gjc = (meta as { gjc?: unknown }).gjc;
+		if (typeof gjc === "object" && gjc !== null && "permissionHandling" in gjc) {
+			return parseAcpPermissionMode((gjc as { permissionHandling?: unknown }).permissionHandling);
+		}
+	}
+	return parseAcpPermissionMode(process.env[ACP_PERMISSION_MODE_ENV]);
+}
+
 export function createAcpClientBridge(
 	connection: AgentSideConnection,
 	sessionId: string,
 	clientCapabilities: ClientCapabilities | undefined,
 ): ClientBridge {
+	const promptPermission = resolveAcpPermissionMode(clientCapabilities) === "prompt";
 	const capabilities: ClientBridgeCapabilities = {
 		readTextFile: clientCapabilities?.fs?.readTextFile === true,
 		writeTextFile: clientCapabilities?.fs?.writeTextFile === true,
 		terminal: clientCapabilities?.terminal === true,
-		// Permission requests are always usable on the connection; gating is
-		// the agent's policy choice rather than a client capability.
-		requestPermission: true,
+		requestPermission: promptPermission,
 	};
 
 	const bridge: ClientBridge = { capabilities, deferAgentInitiatedTurns: true };
@@ -65,8 +85,10 @@ export function createAcpClientBridge(
 			createTerminalHandle(connection, sessionId, params);
 	}
 
-	bridge.requestPermission = (toolCall, options, signal) =>
-		requestPermission(connection, sessionId, toolCall, options, signal);
+	if (promptPermission) {
+		bridge.requestPermission = (toolCall, options, signal) =>
+			requestPermission(connection, sessionId, toolCall, options, signal);
+	}
 
 	return bridge;
 }

package/src/modes/acp/acp-event-mapper.ts

@@ -27,6 +27,8 @@ interface AcpEventMapperOptions {
 	 * before emitting `ToolCallLocation` entries.
 	 */
 	cwd?: string;
+	/** Phase to expose after compaction ends. Prompt-bound compaction resumes responding; idle maintenance returns idle. */
+	compactionEndPhase?: "responding" | "idle";
 }
 
 interface ContentArrayContainer {
@@ -236,8 +238,44 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		case "turn_start":
 		case "turn_end":
 		case "message_start":
+			return [];
 		case "auto_compaction_start":
-		case "auto_compaction_end":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						gjcPhase: "compacting",
+						gjcCompactionState: "start",
+						gjcCompactionTrigger: event.reason,
+						gjcCompactionAction: event.action,
+						running: true,
+						gjcRunning: true,
+					},
+				}),
+			];
+		case "auto_compaction_end": {
+			const phase = options.compactionEndPhase ?? "responding";
+			const running = phase !== "idle";
+			const meta: Record<string, unknown> = {
+				gjcPhase: phase,
+				gjcCompactionState: "end",
+				gjcCompactionAction: event.action,
+				gjcCompactionAborted: event.aborted,
+				gjcCompactionWillRetry: event.willRetry,
+				running,
+				gjcRunning: running,
+			};
+			if (event.skipped !== undefined) {
+				meta.gjcCompactionSkipped = event.skipped;
+			}
+			if (event.errorMessage !== undefined) {
+				meta.gjcCompactionErrorMessage = event.errorMessage;
+			}
+			if (event.continuationSkipReason !== undefined) {
+				meta.gjcCompactionContinuationSkipReason = event.continuationSkipReason;
+			}
+			return [toSessionNotification(sessionId, { sessionUpdate: "session_info_update", _meta: meta })];
+		}
 		case "auto_retry_start":
 		case "auto_retry_end":
 		case "retry_fallback_applied":

package/src/modes/components/model-selector.ts

@@ -121,6 +121,7 @@ export type ModelSelectorSelection =
 interface PendingThinkingChoice {
 	item: ModelItem | CanonicalModelItem;
 	role: GjcModelAssignmentTargetId | null;
+	roles?: readonly GjcModelAssignmentTargetId[];
 	levels: ThinkingLevel[];
 }
 
@@ -1373,7 +1374,13 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	#renderThinkingMenu(choice: PendingThinkingChoice): void {
-		const targetLabel = choice.role === null ? "temporary model" : GJC_MODEL_ASSIGNMENT_TARGETS[choice.role].name;
+		const targetLabel = choice.roles
+			? choice.roles.includes("default")
+				? "all targets"
+				: "all role agents"
+			: choice.role === null
+				? "temporary model"
+				: GJC_MODEL_ASSIGNMENT_TARGETS[choice.role].name;
 		this.#listContainer.addChild(new Spacer(1));
 		this.#listContainer.addChild(
 			new Text(theme.fg("muted", `  Reasoning for ${targetLabel}: ${choice.item.model.id}`), 0, 0),
@@ -1700,14 +1707,16 @@ export class ModelSelectorComponent extends Container {
 			const level = choice.levels[this.#selectedThinkingIndex];
 			if (!level) return;
 			this.#pendingThinkingChoice = undefined;
-			this.#handleSelect(choice.item, choice.role, level);
+			this.#handleSelect(choice.item, choice.role, level, choice.roles);
 			return;
 		}
 		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
 			this.#pendingThinkingChoice = undefined;
 			if (choice.role !== null) {
 				this.#pendingActionItem = choice.item;
-				this.#selectedActionIndex = Math.max(0, GJC_MODEL_ASSIGNMENT_TARGET_IDS.indexOf(choice.role));
+				this.#selectedActionIndex = choice.roles
+					? GJC_MODEL_ASSIGNMENT_TARGET_IDS.length + (choice.roles.includes("default") ? 1 : 0)
+					: Math.max(0, GJC_MODEL_ASSIGNMENT_TARGET_IDS.indexOf(choice.role));
 			}
 			this.#updateList();
 		}
@@ -1736,9 +1745,12 @@ export class ModelSelectorComponent extends Container {
 	): void {
 		const itemThinkingLevel = thinkingLevel ?? item.thinkingLevel;
 		const hasExplicitThinkingChoice = thinkingLevel !== undefined || item.explicitThinkingLevel === true;
-		if (!hasExplicitThinkingChoice && requiresExplicitThinkingChoice(item.model, role)) {
+		const needsExplicitThinkingChoice = roles
+			? roles.some(targetRole => requiresExplicitThinkingChoice(item.model, targetRole))
+			: requiresExplicitThinkingChoice(item.model, role);
+		if (!hasExplicitThinkingChoice && needsExplicitThinkingChoice) {
 			const levels = getSelectableThinkingLevels(item.model);
-			this.#pendingThinkingChoice = { item, role, levels };
+			this.#pendingThinkingChoice = { item, role, roles, levels };
 			this.#selectedThinkingIndex = this.#getInitialThinkingChoiceIndex(item, levels);
 			this.#updateList();
 			return;