@gajae-code/coding-agent 0.8.2 → 0.9.1

package/src/lsp/client.ts

@@ -835,6 +835,7 @@ async function shutdownClientInstance(client: LspClient): Promise<void> {
 	await Promise.race([shutdown, Bun.sleep(5_000)]);
 	await client.owner?.dispose();
 	await client.owner?.awaitExit({ timeoutMs: 1_000 });
+	await Promise.race([client.proc.exited.catch(() => undefined), Bun.sleep(1_000)]);
 }
 
 export async function shutdownClient(key: string): Promise<void> {

package/src/main.ts

@@ -52,6 +52,7 @@ import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-
 import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance";
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
+import { persistTaskTokenLog, resolveTaskTokenLogDir, taskTokenLogFromUsage } from "./task/token-log";
 import type { LspStartupServerInfo } from "./tools";
 import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
@@ -513,8 +514,8 @@ export async function createSessionManager(
 		}
 		return manager;
 	}
-	// Default case (new session) returns undefined, SDK will create one
-	return undefined;
+	const sessionDir = parsed.sessionDir ?? SessionManager.getDefaultSessionDir(cwd, activeSettings.getAgentDir());
+	return SessionManager.create(cwd, sessionDir);
 }
 
 async function maybeAutoChdir(parsed: Args): Promise<void> {
@@ -951,6 +952,46 @@ export async function runRootCommand(
 		modelRegistry,
 		settingsInstance,
 	);
+	// Resolve the token-log dir lazily on the first chat-usage event: a fresh
+	// launch's session dir does not exist yet at this point (the SDK creates it),
+	// so eager resolution would miss it. Re-resolve when the SessionManager id
+	// changes mid-run (fork/new) so root turns keep landing in the SAME
+	// `<session>/token-logs` dir the task executor uses for subagent turns.
+	let rootTokenLogDir: string | undefined;
+	let rootTokenLogSessionId: string | undefined;
+	let rootTokenLogResolved = false;
+	let rootTokenTurn = 0;
+	const baseTelemetry = sessionOptions.telemetry;
+	sessionOptions.telemetry = {
+		...(baseTelemetry ?? {}),
+		onChatUsage: async event => {
+			await baseTelemetry?.onChatUsage?.(event);
+			const currentSessionId = sessionManager?.getSessionId();
+			if (!rootTokenLogResolved || (currentSessionId && currentSessionId !== rootTokenLogSessionId)) {
+				rootTokenLogDir = await resolveTaskTokenLogDir(process.cwd(), sessionManager);
+				// Reset the per-session turn counter when the log dir moves to a new
+				// session so each session's log starts at turn 1.
+				if (rootTokenLogSessionId !== undefined && currentSessionId !== rootTokenLogSessionId) rootTokenTurn = 0;
+				rootTokenLogSessionId = currentSessionId;
+				rootTokenLogResolved = true;
+			}
+			if (!rootTokenLogDir) return;
+			rootTokenTurn += 1;
+			await persistTaskTokenLog(
+				taskTokenLogFromUsage(event.usage, {
+					subagentId: "root",
+					agent: event.agent?.name ?? "main",
+					// Monotonic 1-based sequence of persisted usage events for this
+					// session (event.stepNumber is 0-based and -1 for oneshot spans).
+					turn: rootTokenTurn,
+					at: new Date().toISOString(),
+					model: event.model,
+					cost: event.cost,
+				}),
+				{ dir: rootTokenLogDir },
+			);
+		},
+	};
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive || mode === "rpc-ui";

package/src/memories/index.ts

@@ -1083,7 +1083,18 @@ async function resolveMemoryModel(options: {
 		});
 		if (resolved.model) return resolved.model;
 	}
-	return session.model ?? modelRegistry.getAll()[0];
+	if (session.model) return session.model;
+	// No configured role and no active session model (e.g. background startup
+	// before lazy model resolution): prefer the most recently used model over
+	// raw registry order. `getAll()[0]` can be a retired model the provider
+	// now rejects with 404, which permanently fails consolidation jobs.
+	const allModels = modelRegistry.getAll();
+	const usageOrder = session.settings.getStorage()?.getModelUsageOrder() ?? [];
+	for (const usedKey of usageOrder) {
+		const match = allModels.find(model => `${model.provider}/${model.id}` === usedKey);
+		if (match) return match;
+	}
+	return allModels[0];
 }
 
 function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig {

package/src/modes/components/assistant-message.ts

@@ -55,6 +55,15 @@ function elideRunawayThinkingRepetition(text: string): string {
 	return text;
 }
 
+interface AssistantMessageUpdateOptions {
+	streaming?: boolean;
+}
+
+type AssistantChildDescriptor = {
+	key: string;
+	component: Component;
+};
+
 /**
  * Component that renders a complete assistant message
  */
@@ -67,6 +76,11 @@ export class AssistantMessageComponent extends Container {
 	#kittyConversionsInFlight = new Set<string>();
 	#responseHeader = new Text(theme.bold(theme.fg("statusLineModel", "gajae")), 1, 0);
 	#contentBlocksCache = new WeakMap<object, { source: string; component: Component }>();
+	#lastStreaming = false;
+	#childComponents = new Map<string, Component>();
+	#contentBlockKeys = new WeakMap<object, string>();
+	#nextContentBlockKey = 0;
+	#reusableChildren = new WeakSet<Component>();
 
 	constructor(
 		message?: AssistantMessage,
@@ -87,7 +101,7 @@ export class AssistantMessageComponent extends Container {
 	override invalidate(): void {
 		super.invalidate();
 		if (this.#lastMessage) {
-			this.updateContent(this.#lastMessage);
+			this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
 		}
 	}
 
@@ -115,7 +129,7 @@ export class AssistantMessageComponent extends Container {
 			this.#convertToolImagesForKitty(toolCallId, validImages);
 		}
 		if (this.#lastMessage) {
-			this.updateContent(this.#lastMessage);
+			this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
 		}
 	}
 
@@ -138,7 +152,7 @@ export class AssistantMessageComponent extends Container {
 						mimeType: "image/png",
 					});
 					if (this.#lastMessage) {
-						this.updateContent(this.#lastMessage);
+						this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
 					}
 					this.onImageUpdate?.();
 				})
@@ -151,153 +165,298 @@ export class AssistantMessageComponent extends Container {
 	setUsageInfo(usage: Usage): void {
 		this.#usageInfo = usage;
 		if (this.#lastMessage) {
-			this.updateContent(this.#lastMessage);
+			this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
+		}
+	}
+
+	#contentBlockKey(content: object): string {
+		let key = this.#contentBlockKeys.get(content);
+		if (!key) {
+			key = `block:${this.#nextContentBlockKey++}`;
+			this.#contentBlockKeys.set(content, key);
 		}
+		return key;
 	}
 
-	#renderTextBlock(content: { text: string }): Component {
+	#cachedChild<T extends Component>(key: string, create: () => T): T {
+		const cached = this.#childComponents.get(key);
+		if (cached) return cached as T;
+		const component = create();
+		this.#childComponents.set(key, component);
+		this.#reusableChildren.add(component);
+		return component;
+	}
+
+	#renderTextBlock(content: { text: string }, streaming: boolean): Component {
 		const cached = this.#contentBlocksCache.get(content);
-		if (cached?.source === content.text) return cached.component;
+		if (cached?.source === content.text) {
+			if (cached.component instanceof Markdown) {
+				cached.component.setOnStaleThrottle(this.onImageUpdate);
+				cached.component.setStreaming(streaming);
+			}
+			return cached.component;
+		}
 		const trimmed = content.text.trim();
 		const deepInterview = renderDeepInterviewAssistantText(trimmed, theme);
 		// Reuse the same Markdown instance across streaming chunks (update text in place)
 		// instead of constructing a new one each chunk; combined with the markdown
 		// per-code-block highlight cache, appends no longer re-highlight the whole prefix.
 		if (!deepInterview && cached && cached.component instanceof Markdown) {
-			cached.component.setText(trimmed);
+			cached.component.setOnStaleThrottle(this.onImageUpdate);
+			cached.component.setText(trimmed, { streaming });
 			cached.source = content.text;
 			return cached.component;
 		}
 		const component = deepInterview ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
+		if (component instanceof Markdown) {
+			component.setOnStaleThrottle(this.onImageUpdate);
+			component.setStreaming(streaming);
+		}
 		this.#contentBlocksCache.set(content, { source: content.text, component });
+		this.#reusableChildren.add(component);
 		return component;
 	}
 
-	#renderThinkingBlock(content: { thinking: string }): Markdown {
+	#renderThinkingBlock(content: { thinking: string }, streaming: boolean): Markdown {
 		const cached = this.#contentBlocksCache.get(content);
-		if (cached?.source === content.thinking) return cached.component as Markdown;
+		if (cached?.source === content.thinking) {
+			if (cached.component instanceof Markdown) {
+				cached.component.setOnStaleThrottle(this.onImageUpdate);
+				cached.component.setStreaming(streaming);
+			}
+			return cached.component as Markdown;
+		}
 		const trimmed = elideRunawayThinkingRepetition(content.thinking.trim());
+		if (cached?.component instanceof Markdown) {
+			cached.component.setOnStaleThrottle(this.onImageUpdate);
+			cached.component.setText(trimmed, { streaming });
+			cached.source = content.thinking;
+			return cached.component;
+		}
 		const component = new Markdown(trimmed, 1, 0, getMarkdownTheme(), {
 			color: (text: string) => theme.fg("thinkingText", text),
 			italic: true,
 		});
+		component.setOnStaleThrottle(this.onImageUpdate);
+		component.setStreaming(streaming);
 		this.#contentBlocksCache.set(content, { source: content.thinking, component });
+		this.#reusableChildren.add(component);
 		return component;
 	}
 
-	#renderToolImages(): void {
+	#toolImageDescriptors(): AssistantChildDescriptor[] {
 		const imageEntries = Array.from(this.#toolImagesByCallId.entries()).flatMap(([toolCallId, images]) =>
 			images.map((image, index) => ({ image, key: `${toolCallId}:${index}` })),
 		);
-		if (imageEntries.length === 0) return;
+		if (imageEntries.length === 0) return [];
 
-		this.#contentContainer.addChild(new Spacer(1));
+		const descriptors: AssistantChildDescriptor[] = [
+			{ key: "tool-images:spacer", component: this.#cachedChild("tool-images:spacer", () => new Spacer(1)) },
+		];
 		for (const { image, key } of imageEntries) {
 			const displayImage =
 				TERMINAL.imageProtocol === ImageProtocol.Kitty && image.mimeType !== "image/png"
 					? this.#convertedKittyImages.get(key)
 					: image;
 			if (TERMINAL.imageProtocol && displayImage) {
-				this.#contentContainer.addChild(
-					new Image(
-						displayImage.data,
-						displayImage.mimeType,
-						{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
-						resolveImageOptions(),
+				const imageKey = `tool-image:${key}:${displayImage.mimeType}:${displayImage.data}`;
+				descriptors.push({
+					key: imageKey,
+					component: this.#cachedChild(
+						imageKey,
+						() =>
+							new Image(
+								displayImage.data,
+								displayImage.mimeType,
+								{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
+								resolveImageOptions(),
+							),
 					),
-				);
+				});
 				continue;
 			}
-			this.#contentContainer.addChild(new Text(theme.fg("toolOutput", `[Image: ${image.mimeType}]`), 1, 0));
+			const fallbackKey = `tool-image-fallback:${key}:${image.mimeType}`;
+			descriptors.push({
+				key: fallbackKey,
+				component: this.#cachedChild(
+					fallbackKey,
+					() => new Text(theme.fg("toolOutput", `[Image: ${image.mimeType}]`), 1, 0),
+				),
+			});
 		}
+		return descriptors;
 	}
 
-	updateContent(message: AssistantMessage): void {
-		this.#lastMessage = message;
+	#reconcileChildren(descriptors: AssistantChildDescriptor[]): void {
+		const nextChildren = descriptors.map(descriptor => descriptor.component);
+		if (
+			nextChildren.length === this.#contentContainer.children.length &&
+			nextChildren.every((child, index) => child === this.#contentContainer.children[index])
+		) {
+			return;
+		}
 
-		// Clear content container
-		this.#contentContainer.clear();
+		const nextSet = new Set(nextChildren);
+		for (const child of this.#contentContainer.children) {
+			if (!nextSet.has(child) && !this.#reusableChildren.has(child)) {
+				child.dispose?.();
+			}
+		}
+		this.#contentContainer.children = nextChildren;
+	}
 
-		const hasVisibleContent = message.content.some(
-			c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
-		);
+	updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void {
+		this.#lastMessage = message;
+		this.#lastStreaming = options?.streaming ?? false;
 
+		const visibleContentAfter = new Array<boolean>(message.content.length).fill(false);
+		let hasVisibleContentAfter = false;
+		let hasVisibleContent = false;
+		let activeContentIndex = -1;
+		for (let i = message.content.length - 1; i >= 0; i--) {
+			visibleContentAfter[i] = hasVisibleContentAfter;
+			const content = message.content[i];
+			const isVisible =
+				(content.type === "text" && Boolean(content.text.trim())) ||
+				(content.type === "thinking" && Boolean(content.thinking.trim()));
+			if (isVisible) {
+				hasVisibleContent = true;
+				hasVisibleContentAfter = true;
+				if (this.#lastStreaming && activeContentIndex === -1) {
+					activeContentIndex = i;
+				}
+			}
+		}
+
+		const streaming = this.#lastStreaming;
+		const descriptors: AssistantChildDescriptor[] = [];
 		if (hasVisibleContent) {
-			this.#contentContainer.addChild(new Spacer(1));
-			this.#contentContainer.addChild(this.#responseHeader);
+			descriptors.push({
+				key: "response-header:spacer",
+				component: this.#cachedChild("response-header:spacer", () => new Spacer(1)),
+			});
+			descriptors.push({ key: "response-header", component: this.#responseHeader });
 		}
 
 		// Render content in order
 		for (let i = 0; i < message.content.length; i++) {
 			const content = message.content[i];
+			const blockKey = this.#contentBlockKey(content);
 			if (content.type === "text" && content.text.trim()) {
-				this.#contentContainer.addChild(this.#renderTextBlock(content));
+				descriptors.push({
+					key: `${blockKey}:text`,
+					component: this.#renderTextBlock(content, streaming && i === activeContentIndex),
+				});
 			} else if (content.type === "thinking" && content.thinking.trim()) {
 				// Add spacing only when another visible assistant content block follows.
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
-				const hasVisibleContentAfter = message.content
-					.slice(i + 1)
-					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
-
 				if (this.hideThinkingBlock) {
 					// Show static "Thinking..." label when hidden
-					this.#contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", "Thinking...")), 1, 0));
-					if (hasVisibleContentAfter) {
-						this.#contentContainer.addChild(new Spacer(1));
-					}
+					descriptors.push({
+						key: `${blockKey}:thinking-hidden`,
+						component: this.#cachedChild(
+							`${blockKey}:thinking-hidden`,
+							() => new Text(theme.italic(theme.fg("thinkingText", "Thinking...")), 1, 0),
+						),
+					});
 				} else {
-					this.#contentContainer.addChild(this.#renderThinkingBlock(content));
-					if (hasVisibleContentAfter) {
-						this.#contentContainer.addChild(new Spacer(1));
-					}
+					descriptors.push({
+						key: `${blockKey}:thinking`,
+						component: this.#renderThinkingBlock(content, streaming && i === activeContentIndex),
+					});
+				}
+				if (visibleContentAfter[i]) {
+					descriptors.push({
+						key: `${blockKey}:thinking-spacer`,
+						component: this.#cachedChild(`${blockKey}:thinking-spacer`, () => new Spacer(1)),
+					});
 				}
 			}
 		}
 
-		this.#renderToolImages();
-		// Check if aborted - show after partial content
-		// But only if there are no tool calls (tool execution components will show the error)
-		const hasToolCalls = message.content.some(c => c.type === "toolCall");
-		if (!hasToolCalls) {
-			if (message.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
-				const abortMessage =
-					message.errorMessage && message.errorMessage !== "Request was aborted"
-						? message.errorMessage
-						: "Operation aborted";
-				if (hasVisibleContent) {
-					this.#contentContainer.addChild(new Spacer(1));
-				} else {
-					this.#contentContainer.addChild(new Spacer(1));
+		descriptors.push(...this.#toolImageDescriptors());
+
+		const isTerminal = !streaming || Boolean(message.stopReason);
+		if (isTerminal) {
+			// Check if aborted - show after partial content
+			// But only if there are no tool calls (tool execution components will show the error)
+			const hasToolCalls = message.content.some(c => c.type === "toolCall");
+			if (!hasToolCalls) {
+				if (message.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
+					const abortMessage =
+						message.errorMessage && message.errorMessage !== "Request was aborted"
+							? message.errorMessage
+							: "Operation aborted";
+					descriptors.push({
+						key: "abort:spacer",
+						component: this.#cachedChild("abort:spacer", () => new Spacer(1)),
+					});
+					descriptors.push({
+						key: `abort:text:${abortMessage}`,
+						component: this.#cachedChild(
+							`abort:text:${abortMessage}`,
+							() => new Text(theme.fg("error", abortMessage), 1, 0),
+						),
+					});
+				} else if (message.stopReason === "error") {
+					const errorMsg = message.errorMessage || "Unknown error";
+					descriptors.push({
+						key: "error:spacer",
+						component: this.#cachedChild("error:spacer", () => new Spacer(1)),
+					});
+					descriptors.push({
+						key: `error:text:${errorMsg}`,
+						component: this.#cachedChild(
+							`error:text:${errorMsg}`,
+							() => new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0),
+						),
+					});
 				}
-				this.#contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
-			} else if (message.stopReason === "error") {
-				const errorMsg = message.errorMessage || "Unknown error";
-				this.#contentContainer.addChild(new Spacer(1));
-				this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 			}
-		}
-		if (
-			message.errorMessage &&
-			!isSilentAbort(message.errorMessage) &&
-			message.stopReason !== "aborted" &&
-			message.stopReason !== "error"
-		) {
-			this.#contentContainer.addChild(new Spacer(1));
-			this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${message.errorMessage}`), 1, 0));
-		}
+			if (
+				message.errorMessage &&
+				!isSilentAbort(message.errorMessage) &&
+				message.stopReason !== "aborted" &&
+				message.stopReason !== "error"
+			) {
+				descriptors.push({
+					key: "message-error:spacer",
+					component: this.#cachedChild("message-error:spacer", () => new Spacer(1)),
+				});
+				descriptors.push({
+					key: `message-error:text:${message.errorMessage}`,
+					component: this.#cachedChild(
+						`message-error:text:${message.errorMessage}`,
+						() => new Text(theme.fg("error", `Error: ${message.errorMessage}`), 1, 0),
+					),
+				});
+			}
 
-		// Token usage metadata
-		if (settings.get("display.showTokenUsage") && this.#usageInfo) {
-			const usage = this.#usageInfo;
-			const totalInput = usage.input + usage.cacheWrite;
-			const parts: string[] = [];
-			parts.push(`${theme.icon.input} ${formatNumber(totalInput)}`);
-			parts.push(`${theme.icon.output} ${formatNumber(usage.output)}`);
-			if (usage.cacheRead > 0) {
-				parts.push(`cache: ${formatNumber(usage.cacheRead)}`);
+			// Token usage metadata
+			if (settings.get("display.showTokenUsage") && this.#usageInfo) {
+				const usage = this.#usageInfo;
+				const totalInput = usage.input + usage.cacheWrite;
+				const parts: string[] = [];
+				parts.push(`${theme.icon.input} ${formatNumber(totalInput)}`);
+				parts.push(`${theme.icon.output} ${formatNumber(usage.output)}`);
+				if (usage.cacheRead > 0) {
+					parts.push(`cache: ${formatNumber(usage.cacheRead)}`);
+				}
+				const usageText = parts.join("  ");
+				descriptors.push({
+					key: "usage:spacer",
+					component: this.#cachedChild("usage:spacer", () => new Spacer(1)),
+				});
+				descriptors.push({
+					key: `usage:text:${usageText}`,
+					component: this.#cachedChild(
+						`usage:text:${usageText}`,
+						() => new Text(theme.fg("dim", usageText), 1, 0),
+					),
+				});
 			}
-			this.#contentContainer.addChild(new Spacer(1));
-			this.#contentContainer.addChild(new Text(theme.fg("dim", parts.join("  ")), 1, 0));
 		}
+
+		this.#reconcileChildren(descriptors);
 	}
 }

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

@@ -182,6 +182,7 @@ export class CustomEditor extends Editor {
 	dispose(): void {
 		this.#clearPendingPasteState();
 		this.#pasteHandler = new BracketedPasteHandler();
+		super.dispose();
 	}
 
 	#drainPendingPasteInput(initialInput?: string): void {

package/src/modes/components/footer.ts

@@ -16,6 +16,7 @@ import { resolveCurrentBranch } from "./status-line/git-utils";
 export class FooterComponent implements Component {
 	#cachedBranch: string | null | undefined = undefined; // undefined = not checked yet, null = not in git repo, string = branch name
 	#gitWatcher: fs.FSWatcher | null = null;
+	#gitWatcherGeneration = 0;
 	#onBranchChange: (() => void) | null = null;
 	#autoCompactEnabled: boolean = true;
 	#extensionStatuses: Map<string, string> = new Map();
@@ -51,7 +52,10 @@ export class FooterComponent implements Component {
 	}
 
 	#setupGitWatcher(): void {
-		// Clean up existing watcher
+		// Clean up existing watcher. The generation guard below keeps a stale
+		// in-flight resolve — one that dispose() or a newer setup already
+		// superseded — from installing a watcher nothing would ever close.
+		const generation = ++this.#gitWatcherGeneration;
 		if (this.#gitWatcher) {
 			this.#gitWatcher.close();
 			this.#gitWatcher = null;
@@ -60,7 +64,7 @@ export class FooterComponent implements Component {
 		void git.head
 			.resolve(getProjectDir())
 			.then(head => {
-				if (!head) {
+				if (!head || generation !== this.#gitWatcherGeneration) {
 					return;
 				}
 
@@ -84,6 +88,7 @@ export class FooterComponent implements Component {
 	 * Clean up the file watcher
 	 */
 	dispose(): void {
+		this.#gitWatcherGeneration++;
 		if (this.#gitWatcher) {
 			this.#gitWatcher.close();
 			this.#gitWatcher = null;