@gajae-code/coding-agent 0.12.18 → 0.12.20

package/src/modes/acp/terminal-auth.ts

@@ -23,11 +23,11 @@ export function prepareAcpTerminalAuthArgs(rawArgs: readonly string[]): AcpTermi
 	const args: string[] = [];
 	for (let i = 0; i < withoutAuthFlag.length; i++) {
 		const arg = withoutAuthFlag[i];
-		if (arg === "--mode") {
+		if (arg === "--mode" && withoutAuthFlag[i + 1] === "acp") {
 			i++;
 			continue;
 		}
-		if (arg.startsWith("--mode=")) {
+		if (arg === "--mode=acp") {
 			continue;
 		}
 		args.push(arg);

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

@@ -51,6 +51,7 @@ export class BashExecutionComponent extends Container {
 	#chunkGate = false;
 	#contentContainer: Container;
 	#headerText: Text;
+	#resultPersisted = false;
 
 	constructor(
 		private readonly command: string,
@@ -259,4 +260,17 @@ export class BashExecutionComponent extends Container {
 	getCommand(): string {
 		return this.command;
 	}
+
+	/**
+	 * Record that this execution's message reached session state, so a transcript
+	 * rebuild renders it from the session instead of keeping this live block parked.
+	 */
+	markResultPersisted(): void {
+		this.#resultPersisted = true;
+	}
+
+	/** Whether the session already holds this execution's message. */
+	hasPersistedResult(): boolean {
+		return this.#resultPersisted;
+	}
 }

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

@@ -30,6 +30,7 @@ export class EvalExecutionComponent extends Container {
 	#expanded = false;
 	#contentContainer: Container;
 	#headerText: Text;
+	#resultPersisted = false;
 
 	#highlightLang(): "python" | "javascript" {
 		return this.language === "js" ? "javascript" : "python";
@@ -165,4 +166,17 @@ export class EvalExecutionComponent extends Container {
 	getCode(): string {
 		return this.code;
 	}
+
+	/**
+	 * Record that this execution's message reached session state, so a transcript
+	 * rebuild renders it from the session instead of keeping this live block parked.
+	 */
+	markResultPersisted(): void {
+		this.#resultPersisted = true;
+	}
+
+	/** Whether the session already holds this execution's message. */
+	hasPersistedResult(): boolean {
+		return this.#resultPersisted;
+	}
 }

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

@@ -5,7 +5,7 @@ import { CompactionCancelledError, type CompactionOutcome } from "@gajae-code/ag
 import { getEnvApiKey, type ToolCall, type UsageLimit, type UsageReport } from "@gajae-code/ai/core";
 import type { ProviderDetails } from "@gajae-code/ai/provider-details";
 import { type Keybinding, Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@gajae-code/tui";
-import { formatDuration, Snowflake, setProjectDir } from "@gajae-code/utils";
+import { formatBytes, formatDuration, Snowflake, setProjectDir } from "@gajae-code/utils";
 import { resolveAppendOnlyMode } from "../../append-only-mode";
 import { jobElapsedMs } from "../../async";
 import { reset as resetCapabilities } from "../../capability";
@@ -39,7 +39,7 @@ import { getDisplayChangelogEntries } from "../../utils/changelog";
 import { copyToClipboard } from "../../utils/clipboard";
 import { openPath } from "../../utils/open";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
-import { prepareTranscriptRebuild } from "../utils/ui-helpers";
+import { addChatChild, prepareTranscriptRebuild, syncPendingExecutionComponents } from "../utils/ui-helpers";
 
 type HindsightModule = typeof import("../../hindsight");
 let hindsightModulePromise: Promise<HindsightModule> | undefined;
@@ -473,6 +473,45 @@ export class CommandController {
 			const settingLabel = setting === "auto" ? `${setting} (${provider ?? "?"})` : setting;
 			info += `${theme.fg("dim", "Append-Only:")} ${activeLabel} (setting: ${settingLabel})\n`;
 		}
+		if (stats.sessionMemory) {
+			const memory = stats.sessionMemory;
+			const retirement = memory.coldRetirementActive ? theme.fg("success", "active") : theme.fg("dim", "inactive");
+			info += `\n${theme.bold("Session Memory")}\n`;
+			info += `${theme.fg("dim", "Cold Retirement:")} ${retirement}\n`;
+			info += `${theme.fg("dim", "Hot Region:")} ${formatBytes(memory.hotRegionBytes)}\n`;
+			info += `${theme.fg("dim", "Metadata:")} ${formatBytes(memory.metaDescriptorBytes)}\n`;
+			info += `${theme.fg("dim", "Accounted:")} ${formatBytes(memory.totalAccountedBytes)}\n`;
+			if (memory.coldIndexBytes > 0 || memory.coldIndexBlockCacheBytes > 0 || memory.coldEntryCacheBytes > 0) {
+				info += `${theme.fg("dim", "Cold Index/Caches:")} ${formatBytes(memory.coldIndexBytes)} / ${formatBytes(memory.coldIndexBlockCacheBytes)} / ${formatBytes(memory.coldEntryCacheBytes)}\n`;
+			}
+			if (memory.lazyReopenAttempted) {
+				const reopen = memory.lazyReopenSucceeded ? theme.fg("success", "exact") : theme.fg("warning", "fallback");
+				info += `${theme.fg("dim", "Lazy Reopen:")} ${reopen}\n`;
+			}
+			const fallbackReason = memory.retirementFallbackReason ?? memory.lazyReopenFallbackReason;
+			if (fallbackReason) info += `${theme.fg("dim", "Fallback Reason:")} ${fallbackReason}\n`;
+			if (memory.coldEntriesRetired > 0 || memory.coldEntriesReloaded > 0) {
+				info += `${theme.fg("dim", "Cold Retired/Reloaded:")} ${memory.coldEntriesRetired}/${memory.coldEntriesReloaded}\n`;
+			}
+			if (memory.rangeReadCount > 0 || memory.rangeReadGenerationMismatchCount > 0) {
+				info += `${theme.fg("dim", "Cold Range Reads:")} ${memory.rangeReadCount} (${memory.rangeReadGenerationMismatchCount} mismatched)\n`;
+			}
+			if (memory.sidecarRebuildCount > 0 || memory.transcriptGeneration > 0) {
+				info += `${theme.fg("dim", "Sidecar Rebuilds:")} ${memory.sidecarRebuildCount} (gen ${memory.transcriptGeneration})\n`;
+			}
+			if (memory.coldMutationPromotions > 0 || memory.hotOverflowTransitions > 0) {
+				info += `${theme.fg("dim", "Cold Promotions/Overflows:")} ${memory.coldMutationPromotions}/${memory.hotOverflowTransitions}\n`;
+			}
+			if (memory.labelDiskFallbackCount > 0) {
+				info += `${theme.fg("dim", "Label Disk Reads:")} ${memory.labelDiskFallbackCount}\n`;
+			}
+			if (memory.shadowParityCheckCount > 0) {
+				info += `${theme.fg("dim", "Shadow Parity:")} ${memory.shadowParityMismatchCount}/${memory.shadowParityCheckCount} mismatches\n`;
+			}
+			if (memory.autoDisabledReason) {
+				info += `${theme.fg("dim", "Auto-Disabled:")} ${theme.fg("warning", memory.autoDisabledReason)}\n`;
+			}
+		}
 		info += `${theme.bold("Tokens")}\n`;
 		info += `${theme.fg("dim", "Input:")} ${stats.tokens.input.toLocaleString()}\n`;
 		info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
@@ -1147,7 +1186,8 @@ export class CommandController {
 
 	async handleBashCommand(command: string, excludeFromContext = false): Promise<void> {
 		const isDeferred = this.ctx.session.isStreaming;
-		this.ctx.bashComponent = new BashExecutionComponent(command, this.ctx.ui, excludeFromContext);
+		const component = new BashExecutionComponent(command, this.ctx.ui, excludeFromContext);
+		this.ctx.bashComponent = component;
 
 		if (isDeferred) {
 			this.ctx.pendingMessagesContainer.addChild(this.ctx.bashComponent);
@@ -1165,7 +1205,9 @@ export class CommandController {
 						this.ctx.bashComponent.appendOutput(chunk);
 					}
 				},
-				{ excludeFromContext },
+				// A transcript rebuild racing this call must drop the parked block once the
+				// session owns its message, otherwise the rebuilt row is rendered twice.
+				{ excludeFromContext, onPersisted: () => component.markResultPersisted() },
 			);
 
 			if (this.ctx.bashComponent) {
@@ -1182,8 +1224,18 @@ export class CommandController {
 			this.ctx.showError(`Bash command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
 		const bashComponent = this.ctx.bashComponent;
-		if (isDeferred && bashComponent && this.ctx.pendingBashComponents.includes(bashComponent)) {
-			this.ctx.pendingMessagesContainer.detachChild(bashComponent);
+		if (isDeferred && bashComponent) {
+			// Parentage is the container's answer, never this bookkeeping's: `/clear`,
+			// `/context-clear`, extension redraws and the selector all call
+			// `pendingMessagesContainer.clear()`, which disposes and evicts the parked
+			// component while leaving it listed in `pendingBashComponents`. Ask the
+			// container whether it still holds a live child before moving anything;
+			// a disposed block is terminal and must never reach a fresh transcript.
+			if (this.ctx.pendingMessagesContainer.hasLiveChild(bashComponent)) {
+				this.ctx.pendingMessagesContainer.detachChild(bashComponent);
+				addChatChild(this.ctx, bashComponent);
+			}
+			syncPendingExecutionComponents(this.ctx);
 		}
 
 		this.ctx.bashComponent = undefined;
@@ -1192,7 +1244,8 @@ export class CommandController {
 
 	async handlePythonCommand(code: string, excludeFromContext = false): Promise<void> {
 		const isDeferred = this.ctx.session.isStreaming;
-		this.ctx.pythonComponent = new EvalExecutionComponent(code, this.ctx.ui, excludeFromContext);
+		const component = new EvalExecutionComponent(code, this.ctx.ui, excludeFromContext);
+		this.ctx.pythonComponent = component;
 
 		if (isDeferred) {
 			this.ctx.pendingMessagesContainer.addChild(this.ctx.pythonComponent);
@@ -1210,7 +1263,9 @@ export class CommandController {
 						this.ctx.pythonComponent.appendOutput(chunk);
 					}
 				},
-				{ excludeFromContext },
+				// A transcript rebuild racing this call must drop the parked block once the
+				// session owns its message, otherwise the rebuilt row is rendered twice.
+				{ excludeFromContext, onPersisted: () => component.markResultPersisted() },
 			);
 
 			if (this.ctx.pythonComponent) {

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

@@ -281,6 +281,31 @@ export function addChatChild(ctx: InteractiveModeContext, component: Component):
 	trimChatChildren(ctx);
 }
 
+/**
+ * Parked `!`/`$` execution components are listed in `pendingBashComponents` /
+ * `pendingPythonComponents`, but `pendingMessagesContainer` is the only
+ * authority on parentage: `/clear`, `/context-clear`, extension redraws and the
+ * selector all call `pendingMessagesContainer.clear()`, which disposes and
+ * evicts parked components without touching those arrays. Drop every entry the
+ * container no longer holds so nothing downstream can move a dead component.
+ */
+export function syncPendingExecutionComponents(ctx: InteractiveModeContext): void {
+	const container = ctx.pendingMessagesContainer;
+	ctx.pendingBashComponents = ctx.pendingBashComponents.filter(component => container.hasLiveChild(component));
+	ctx.pendingPythonComponents = ctx.pendingPythonComponents.filter(component => container.hasLiveChild(component));
+}
+
+/**
+ * Whether the session already owns this execution's message, i.e. the rebuilt
+ * transcript renders the block from session state. Set by the controller when
+ * `executeBash()` / `executePython()` reports the result as persisted.
+ */
+function hasPersistedExecutionResult(component: Component): boolean {
+	if (component instanceof BashExecutionComponent) return component.hasPersistedResult();
+	if (component instanceof EvalExecutionComponent) return component.hasPersistedResult();
+	return false;
+}
+
 export function trimChatChildren(ctx: InteractiveModeContext): void {
 	const children = ctx.chatContainer.children;
 
@@ -899,10 +924,24 @@ export class UiHelpers {
 		// This path is used to rebuild the visible chat transcript (e.g. after custom/debug UI).
 		// Clear existing rendered chat first to avoid duplicating the full session in the container.
 		const preservedChatChildren = options.preserveExistingChat ? this.ctx.chatContainer.children : undefined;
+		// A still-running deferred `!`/`$` block is the only rendering of output whose
+		// message has not been published to the session yet, so the rebuild must keep it
+		// parked instead of disposing it. Finished blocks are dropped here: the rebuilt
+		// transcript renders them from the session. A block whose result was persisted
+		// while its controller was still suspended is finished for this purpose — keeping
+		// it would render the same execution twice.
+		const runningExecutionComponents = this.#detachPendingMessages(
+			component =>
+				(component === this.ctx.bashComponent || component === this.ctx.pythonComponent) &&
+				!hasPersistedExecutionResult(component),
+		);
+		this.ctx.pendingBashComponents = this.ctx.pendingBashComponents.filter(component =>
+			runningExecutionComponents.includes(component),
+		);
+		this.ctx.pendingPythonComponents = this.ctx.pendingPythonComponents.filter(component =>
+			runningExecutionComponents.includes(component),
+		);
 		this.ctx.chatContainer.clear();
-		this.ctx.pendingMessagesContainer.clear();
-		this.ctx.pendingBashComponents = [];
-		this.ctx.pendingPythonComponents = [];
 
 		// Reuse a pre-built context when available (e.g. from navigateTree) to avoid a second O(N) walk.
 		const context = prebuiltContext ?? this.ctx.sessionManager.buildSessionContext();
@@ -923,6 +962,9 @@ export class UiHelpers {
 			const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
 			this.ctx.showStatus(`Session compacted ${times}`);
 		}
+		for (const component of runningExecutionComponents) {
+			this.ctx.pendingMessagesContainer.addChild(component);
+		}
 		if (preservedChatChildren && preservedChatChildren.length > 0) {
 			for (const child of preservedChatChildren) {
 				addChatChild(this.ctx, child);
@@ -978,8 +1020,35 @@ export class UiHelpers {
 		this.ctx.ui.requestRender();
 	}
 
+	/**
+	 * Empty the pending container, disposing the queued-message chips but handing back
+	 * the parked `!`/`$` execution components matched by `retain`, in render order.
+	 *
+	 * `Container.clear()` disposes every child, which would tear down a running
+	 * execution block mid-flight; retained components are reused instances that the
+	 * caller re-attaches (pending area or chat transcript).
+	 */
+	#detachPendingMessages(retain: (component: Component) => boolean): Component[] {
+		syncPendingExecutionComponents(this.ctx);
+		const parked = new Set<Component>([...this.ctx.pendingBashComponents, ...this.ctx.pendingPythonComponents]);
+		const retained: Component[] = [];
+		for (const child of this.ctx.pendingMessagesContainer.children) {
+			if (parked.has(child) && retain(child)) {
+				retained.push(child);
+			} else {
+				child.dispose?.();
+			}
+		}
+		this.ctx.pendingMessagesContainer.detachAll();
+		return retained;
+	}
+
 	updatePendingMessagesDisplay(): void {
-		this.ctx.pendingMessagesContainer.clear();
+		// Rebuild only the queued-message chips: parked execution components stay attached
+		// so a mid-turn queue/dequeue event cannot dispose a streaming `!`/`$` block.
+		for (const component of this.#detachPendingMessages(() => true)) {
+			this.ctx.pendingMessagesContainer.addChild(component);
+		}
 		const queuedMessages = this.ctx.session.getQueuedMessages() as QueuedMessages;
 
 		const steeringMessages: Array<{ message: string; label: string }> = [];
@@ -1237,20 +1306,21 @@ export class UiHelpers {
 		}
 	}
 
-	/** Move pending bash components from pending area to chat */
+	/** Move pending bash/python components from the pending area to chat */
 	flushPendingBashComponents(): void {
 		// Move (detach, not dispose) the live execution components from the pending
 		// area into the chat transcript — they are reused instances, so a disposing
-		// removeChild() would tear them down before re-adding.
-		for (const component of this.ctx.pendingBashComponents) {
+		// removeChild() would tear them down before re-adding. Walk the container so
+		// the transcript keeps the order the pending area rendered, and so a
+		// component the container no longer holds can never be re-parented.
+		syncPendingExecutionComponents(this.ctx);
+		const parked = new Set<Component>([...this.ctx.pendingBashComponents, ...this.ctx.pendingPythonComponents]);
+		for (const component of [...this.ctx.pendingMessagesContainer.children]) {
+			if (!parked.has(component)) continue;
 			this.ctx.pendingMessagesContainer.detachChild(component);
 			addChatChild(this.ctx, component);
 		}
 		this.ctx.pendingBashComponents = [];
-		for (const component of this.ctx.pendingPythonComponents) {
-			this.ctx.pendingMessagesContainer.detachChild(component);
-			addChatChild(this.ctx, component);
-		}
 		this.ctx.pendingPythonComponents = [];
 	}
 

package/src/sdk/acp/adapter.ts

@@ -1,10 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { HEARTBEAT_TTL_MS } from "../bus/daemon-paths";
-import { SdkClient, SdkClientError, type SdkClientOptions, type SdkFrame } from "../client";
+import { lifecycleRequestTimeoutMs } from "../broker/startup-budget";
+import { SdkClient, SdkClientError, type SdkFrame } from "../client";
 import { assertReverseResponseFrame, ReverseLeaseError } from "../host/reverse-leases";
 import { validateAdapterControl, validateAdapterSecretFields } from "../protocol/adapter-validation";
-
 import { OPERATIONS } from "../protocol/operation-registry";
+import { ACP_SESSION_RECONNECT } from "../session-reconnect";
+import type { SessionLifecycleMcpServer } from "./mcp";
 
 type JsonObject = Record<string, unknown>;
 
@@ -40,6 +41,40 @@ export class AcpSdkAdapterError extends Error {
 	}
 }
 
+/**
+ * Lifecycle failures the ACP MCP launch wrapper must report verbatim. Everything else
+ * is re-attributed to the configured MCP servers, which is the useful answer for a
+ * launch that actually reached them — but a startup the broker ended before admission
+ * never opened an MCP handshake, so blaming the servers would hide both the real
+ * authority reason and the fact that the request is safely retryable.
+ */
+const ACP_MCP_PRESERVED_LAUNCH_CODES = new Set([
+	"invalid_input",
+	"authentication_failed",
+	"unknown_model_profile",
+	"model_profile_registry_error",
+	"startup_admission_refused",
+	"startup_admission_timeout",
+]);
+
+/**
+ * The error an ACP session launch must throw once a lifecycle request that carried MCP
+ * servers has failed.
+ */
+export function acpMcpLaunchFailure(error: unknown, mcpServers: SessionLifecycleMcpServer[]): unknown {
+	const code =
+		typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+			? error.code
+			: undefined;
+	if (mcpServers.length === 0 || (code !== undefined && ACP_MCP_PRESERVED_LAUNCH_CODES.has(code))) return error;
+	const names = mcpServers
+		.slice(0, 8)
+		.map(server => server.name)
+		.join(", ");
+	const suffix = mcpServers.length > 8 ? `, and ${mcpServers.length - 8} more` : "";
+	return new AcpSdkAdapterError("unavailable", `MCP server request failed to start (${names}${suffix}).`);
+}
+
 export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
 export type AcpFrameHandler = (frame: SdkFrame) => void;
 type ReverseRequest = {
@@ -48,43 +83,7 @@ type ReverseRequest = {
 	cancelTimer?: NodeJS.Timeout;
 };
 
-type AcpSessionReconnectOptions = Required<
-	Pick<SdkClientOptions, "reconnectAttempts" | "reconnectBackoffMs" | "reconnectMaxBackoffMs">
->;
-
-const ACP_RECONNECT_BACKOFF_MS = 250;
-const ACP_RECONNECT_MAX_BACKOFF_MS = 2_000;
-/** Cover twice the host heartbeat TTL so a reaped stall still has room to recover. */
-const ACP_RECONNECT_BUDGET_MS = 2 * HEARTBEAT_TTL_MS;
-
-function attemptsCovering(budgetMs: number): number {
-	let elapsed = 0;
-	let attempts = 0;
-	while (elapsed <= budgetMs) {
-		elapsed += Math.min(ACP_RECONNECT_BACKOFF_MS * 2 ** attempts, ACP_RECONNECT_MAX_BACKOFF_MS);
-		attempts++;
-	}
-	return attempts;
-}
-
-/**
- * Reconnect budget for long-lived ACP sessions.
- *
- * Invariant: the client's total reconnect budget must outlive the host heartbeat
- * TTL ({@link HEARTBEAT_TTL_MS}). The SDK host drops a session whose client has
- * not ponged within that TTL, so a client that gives up reconnecting sooner turns
- * every stall the host reaps into a permanently lost session ("SDK WebSocket
- * reconnect attempts exhausted"). The transport defaults (3 attempts at 25ms base
- * = 175ms total) are correct only for one-shot request clients.
- *
- * Backoff ramps 250 -> 500 -> 1000 and then holds at the 2s cap, so individual
- * sleeps stay short and recovery is prompt once the host answers again.
- */
-export const ACP_SESSION_RECONNECT: AcpSessionReconnectOptions = {
-	reconnectAttempts: attemptsCovering(ACP_RECONNECT_BUDGET_MS),
-	reconnectBackoffMs: ACP_RECONNECT_BACKOFF_MS,
-	reconnectMaxBackoffMs: ACP_RECONNECT_MAX_BACKOFF_MS,
-};
+export { ACP_SESSION_RECONNECT };
 
 const SESSION_GLOBALS: Record<string, string> = {
 	newSession: "session.create",
@@ -224,13 +223,15 @@ export class AcpSdkAdapter {
 		this.#assertGenericDisposition("global", operation);
 		if (isLifecycleOperation(operation) && !idempotencyKey)
 			throw new AcpSdkAdapterError("invalid_input", "idempotencyKey is required for lifecycle operations.");
-		const readinessTimeoutMs =
-			typeof input.readinessTimeoutMs === "number" && Number.isSafeInteger(input.readinessTimeoutMs)
-				? input.readinessTimeoutMs
-				: undefined;
+		// The broker may hold a startup in its admission queue before the readiness
+		// clock even starts, so the caller deadline covers the queue wait too; sizing
+		// it on readiness alone times out requests the broker is still running. A
+		// request that named no readiness budget is queued for the default one, so it
+		// needs the same extension rather than the client's generic request deadline.
+		const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
 		return await this.#client.global(operation, input, {
 			idempotencyKey,
-			...(readinessTimeoutMs ? { timeoutMs: readinessTimeoutMs + 1_000 } : {}),
+			...(timeoutMs === undefined ? {} : { timeoutMs }),
 		});
 	}
 

package/src/sdk/acp/index.ts

@@ -1,2 +1,2 @@
 export type { AcpProviderRegistration, AcpReverseConnection, AcpSdkAdapterOptions } from "./adapter";
-export { ACP_SESSION_RECONNECT, AcpSdkAdapter, AcpSdkAdapterError } from "./adapter";
+export { ACP_SESSION_RECONNECT, AcpSdkAdapter, AcpSdkAdapterError, acpMcpLaunchFailure } from "./adapter";