@gajae-code/coding-agent 0.18.7 → 0.18.9

package/src/memories/index.ts

@@ -3,7 +3,14 @@ import type * as fsNode from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@gajae-code/agent-core";
-import { completeSimple, Effort, type Model } from "@gajae-code/ai/core";
+import { estimateTextTokensHeuristic } from "@gajae-code/agent-core/compaction";
+import {
+	ANTHROPIC_THINKING,
+	completeSimple,
+	Effort,
+	type Model,
+	resolveDefaultRequestMaxTokens,
+} from "@gajae-code/ai/core";
 import { clampThinkingLevelForModel } from "@gajae-code/ai/model-thinking";
 import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
@@ -74,6 +81,20 @@ const DEFAULTS: MemoryRuntimeConfig = {
 	summaryInjectionTokenLimit: 5_000,
 };
 
+const PHASE2_RAW_MEMORIES_TOKEN_LIMIT = 20_000;
+const PHASE2_ROLLOUT_SUMMARIES_TOKEN_LIMIT = 12_000;
+// Ceiling for the phase 2 response. Phase 2 rewrites MEMORY.md, the summary and every
+// skill in one JSON response, and on adaptive-thinking / reasoning-effort models the
+// reasoning shares this budget. Twice the (approximate) input caps is a generous
+// practical ceiling, not a guarantee that every response fits; a response that still
+// overruns it is reported as truncation.
+const PHASE2_MAX_OUTPUT_TOKENS = 2 * (PHASE2_RAW_MEMORIES_TOKEN_LIMIT + PHASE2_ROLLOUT_SUMMARIES_TOKEN_LIMIT);
+// On a small context window phase 2 shrinks its inputs rather than let the response
+// budget drop below the previous fixed budget.
+const PHASE2_MIN_OUTPUT_TOKENS = 8_192;
+// Request framing plus estimator error when fitting input + output into the context window.
+const PHASE2_CONTEXT_SAFETY_TOKENS = 2_048;
+
 interface Stage1Stats {
 	claimed: number;
 	succeeded: number;
@@ -738,10 +759,8 @@ async function runConsolidationModel(options: {
 	const { memoryRoot, model, apiKey } = options;
 	const rawMemories = await Bun.file(path.join(memoryRoot, "raw_memories.md")).text();
 	const rolloutSummaries = await readRolloutSummaries(memoryRoot);
-	const input = prompt.render(consolidationTemplate, {
-		raw_memories: truncateByApproxTokens(rawMemories, 20_000),
-		rollout_summaries: truncateByApproxTokens(rolloutSummaries, 12_000),
-	});
+	const reasoning = clampThinkingLevelForModel(model, Effort.Low);
+	const { input, maxTokens } = buildPhase2Request(model, rawMemories, rolloutSummaries, reasoning);
 
 	const response = await completeSimple(
 		model,
@@ -751,18 +770,27 @@ async function runConsolidationModel(options: {
 		{
 			apiKey,
 			metadata: options.metadata,
-			maxTokens: 8192,
-			reasoning: clampThinkingLevelForModel(model, Effort.Medium),
+			maxTokens,
+			reasoning,
 		},
 	);
 	if (response.stopReason === "error") {
 		throw new Error(response.errorMessage || "phase2 model error");
 	}
+	if (response.stopReason === "length") {
+		throw new Error(`phase2 output truncated at the max output token limit (${response.usage.output} output tokens)`);
+	}
 	const text = response.content
 		.filter((c): c is { type: "text"; text: string } => c.type === "text")
 		.map(c => c.text)
 		.join("\n")
 		.trim();
+	if (!text) {
+		const thinkingBlocks = response.content.filter(c => c.type === "thinking").length;
+		throw new Error(
+			`phase2 returned no text (stopReason=${response.stopReason}, ${response.usage.output} output tokens, ${thinkingBlocks} thinking blocks)`,
+		);
+	}
 	const parsed = parseJsonObject(text);
 	if (!parsed) throw new Error("phase2 JSON parse failure");
 	const schemaOutput = parseConsolidationOutputSchema(parsed);
@@ -1101,6 +1129,59 @@ function truncateByApproxTokens(text: string, tokenLimit: number): string {
 	return `${text.slice(0, head)}\n\n...[truncated]...\n\n${text.slice(-tail)}`;
 }
 
+/**
+ * Render the phase 2 prompt and choose its response budget.
+ *
+ * The budget is the model's output limit capped at PHASE2_MAX_OUTPUT_TOKENS (or the
+ * provider layer's request default when the limit is unknown). When the context window
+ * is known, input + response + any thinking budget the provider adds on top must fit
+ * in it: the response budget is clamped to the remaining room, and the inputs are
+ * shrunk when that room would fall below PHASE2_MIN_OUTPUT_TOKENS.
+ */
+function buildPhase2Request(
+	model: Model,
+	rawMemories: string,
+	rolloutSummaries: string,
+	reasoning: Effort | undefined,
+): { input: string; maxTokens: number | undefined } {
+	const outputLimit =
+		Number.isSafeInteger(model.maxTokens) && model.maxTokens > 0
+			? Math.min(model.maxTokens, PHASE2_MAX_OUTPUT_TOKENS)
+			: undefined;
+	let rawTokens = Math.min(PHASE2_RAW_MEMORIES_TOKEN_LIMIT, Math.ceil(rawMemories.length / 4));
+	let rolloutTokens = Math.min(PHASE2_ROLLOUT_SUMMARIES_TOKEN_LIMIT, Math.ceil(rolloutSummaries.length / 4));
+	const render = () =>
+		prompt.render(consolidationTemplate, {
+			raw_memories: truncateByApproxTokens(rawMemories, rawTokens),
+			rollout_summaries: truncateByApproxTokens(rolloutSummaries, rolloutTokens),
+		});
+
+	const contextWindow =
+		Number.isSafeInteger(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : undefined;
+	if (contextWindow === undefined) return { input: render(), maxTokens: outputLimit };
+
+	const responseCeiling = resolveDefaultRequestMaxTokens(model, outputLimit);
+	const minResponse = Math.min(PHASE2_MIN_OUTPUT_TOKENS, responseCeiling);
+	// Budget-mode providers may add the thinking budget on top of maxTokens.
+	const addsThinkingBudget = model.thinking?.mode === "budget" || model.thinking?.mode === "anthropic-budget-effort";
+	const thinkingReserve = reasoning && addsThinkingBudget ? ANTHROPIC_THINKING[reasoning] : 0;
+	const inputRoom = contextWindow - PHASE2_CONTEXT_SAFETY_TOKENS - thinkingReserve - minResponse;
+
+	for (let attempt = 0; attempt < 4; attempt++) {
+		const input = render();
+		const inputTokens = estimateTextTokensHeuristic(input);
+		if (inputTokens <= inputRoom) {
+			const room = contextWindow - PHASE2_CONTEXT_SAFETY_TOKENS - thinkingReserve - inputTokens;
+			return { input, maxTokens: Math.min(responseCeiling, room) };
+		}
+		if (inputRoom <= 0 || rawTokens + rolloutTokens === 0) break;
+		const scale = (inputRoom / inputTokens) * 0.9;
+		rawTokens = Math.floor(rawTokens * scale);
+		rolloutTokens = Math.floor(rolloutTokens * scale);
+	}
+	throw new Error(`phase2 input does not fit the model context window (${contextWindow} tokens)`);
+}
+
 function computeModelTokenBudget(model: Model, config: MemoryRuntimeConfig): number {
 	const maxTokens =
 		Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : config.fallbackTokenLimit;

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);
 	}

package/src/modes/components/customization/customization-dashboard.ts

@@ -20,6 +20,7 @@
  */
 import { Container, matchesKey, type SelectItem, SelectList, Text } from "@gajae-code/tui";
 import { sanitizeText } from "@gajae-code/utils";
+import { resolveGlobalUserSkillLinkTrust } from "../../../config/skill-settings-defaults";
 import { type CustomizationInventory, loadCustomizationInventory } from "../../../customization/inventory";
 import {
 	removeHookFile,
@@ -47,6 +48,7 @@ import { ImportWizard } from "./import-wizard";
 /** Minimal settings slice the dashboard reads and writes. */
 export interface CustomizationSettingsSlice {
 	get(key: string): unknown;
+	getGlobal?(key: string): unknown;
 	set?(key: string, value: unknown): void;
 }
 
@@ -150,6 +152,16 @@ export class CustomizationDashboard extends Container {
 			cwd: this.#cwd,
 			home: this.#homeDir,
 			policy: this.#skillPolicy(),
+			allowExternalUserSkillSymlinks: resolveGlobalUserSkillLinkTrust({
+				trustUserSkills:
+					typeof this.#settings?.getGlobal === "function"
+						? (this.#settings.getGlobal("skills.trustUserSkills") as boolean | undefined)
+						: undefined,
+				enablePiUser:
+					typeof this.#settings?.getGlobal === "function"
+						? (this.#settings.getGlobal("skills.enablePiUser") as boolean | undefined)
+						: undefined,
+			}),
 			disabledExtensions: this.#getStringArray("disabledExtensions"),
 		});
 	}

package/src/modes/components/extensions/extension-dashboard.ts

@@ -59,7 +59,7 @@ export class ExtensionDashboard extends Container {
 	async #init(): Promise<void> {
 		const sm = this.settings ?? (await Settings.init());
 		const disabledIds = sm ? ((sm.get("disabledExtensions") as string[]) ?? []) : [];
-		this.#state = await createInitialState(this.cwd, disabledIds);
+		this.#state = await createInitialState(this.cwd, disabledIds, sm);
 
 		// Calculate max visible items based on terminal height
 		// Reserve ~10 lines for header, tabs, help text, borders
@@ -193,7 +193,7 @@ export class ExtensionDashboard extends Container {
 
 		const sm = this.settings ?? Settings.instance;
 		const disabledIds = sm ? ((sm.get("disabledExtensions") as string[]) ?? []) : [];
-		const nextState = await refreshState(this.#state, this.cwd, disabledIds);
+		const nextState = await refreshState(this.#state, this.cwd, disabledIds, sm);
 		if (refreshToken !== this.#refreshToken) return;
 		this.#state = nextState;
 

package/src/modes/components/extensions/state-manager.ts

@@ -14,6 +14,7 @@ import type { Skill } from "../../../capability/skill";
 import type { SlashCommand } from "../../../capability/slash-command";
 import type { CustomTool } from "../../../capability/tool";
 import type { SourceMeta } from "../../../capability/types";
+import type { Settings } from "../../../config/settings";
 import {
 	disableProvider,
 	enableProvider,
@@ -43,7 +44,11 @@ export interface ExtensionSettingsManager {
 /**
  * Load all extensions from all capabilities.
  */
-export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): Promise<Extension[]> {
+export async function loadAllExtensions(
+	cwd?: string,
+	disabledIds?: string[],
+	settings?: Settings,
+): Promise<Extension[]> {
 	const extensions: Extension[] = [];
 	const disabledExtensions = new Set<string>(disabledIds ?? []);
 
@@ -97,7 +102,7 @@ export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): P
 		}
 	}
 
-	const loadOpts = cwd ? { cwd, includeDisabled: true } : { includeDisabled: true };
+	const loadOpts = cwd ? { cwd, includeDisabled: true, settings } : { includeDisabled: true, settings };
 
 	// Load skills
 	try {
@@ -553,8 +558,12 @@ export function applyDisabledExtensionsToState(state: DashboardState, disabledId
 /**
  * Create initial dashboard state.
  */
-export async function createInitialState(cwd?: string, disabledIds?: string[]): Promise<DashboardState> {
-	const extensions = await loadAllExtensions(cwd, disabledIds);
+export async function createInitialState(
+	cwd?: string,
+	disabledIds?: string[],
+	settings?: Settings,
+): Promise<DashboardState> {
+	const extensions = await loadAllExtensions(cwd, disabledIds, settings);
 	const tabs = buildProviderTabs(extensions);
 	const tabFiltered = extensions; // "all" tab by default
 	const searchFiltered = tabFiltered;
@@ -592,8 +601,9 @@ export async function refreshState(
 	state: DashboardState,
 	cwd?: string,
 	disabledIds?: string[],
+	settings?: Settings,
 ): Promise<DashboardState> {
-	const extensions = await loadAllExtensions(cwd, disabledIds);
+	const extensions = await loadAllExtensions(cwd, disabledIds, settings);
 	const tabs = buildProviderTabs(extensions);
 
 	// Get current provider from tabs

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

@@ -146,7 +146,7 @@ export class HookEditorComponent extends Container {
 
 		const currentText = this.#editor.getExpandedText();
 		try {
-			this.#tui.stop();
+			this.#tui.suspend();
 			const result = await openInEditor(editorCmd, currentText);
 			if (result !== null) {
 				this.#editor.setText(result);

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

@@ -734,7 +734,7 @@ export class HookSelectorComponent extends Container {
 
 		const currentText = editor.getExpandedText();
 		try {
-			this.#tui.stop();
+			this.#tui.suspend();
 			const result = await openInEditor(editorCmd, currentText);
 			if (result !== null) {
 				editor.setText(result);

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

@@ -1369,10 +1369,7 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	#getProfileAvailableModels(): Model[] {
-		const getAvailableForProfileActivation = this.#modelRegistry.getAvailableForProfileActivation;
-		return typeof getAvailableForProfileActivation === "function"
-			? getAvailableForProfileActivation.call(this.#modelRegistry)
-			: this.#modelRegistry.getAvailable();
+		return this.#modelRegistry.getAvailable();
 	}
 
 	#createProfileResolutionRegistry(availableModels: readonly Model[]) {

package/src/modes/components/provider-onboarding-selector.ts

@@ -30,7 +30,7 @@ const PROVIDER_ONBOARDING_OPTIONS: ProviderOnboardingOption[] = [
 	},
 	{
 		label: "Import existing credentials",
-		description: "Detect and import Claude Code / Codex CLI logins already on this machine.",
+		description: "Detect and import Claude Code / Codex CLI / Kiro CLI logins already on this machine.",
 		action: "import-credentials",
 	},
 ];

package/src/modes/components/status-line/segments.ts

@@ -109,6 +109,10 @@ const modelSegment: StatusLineSegment = {
 		const modelName = shortenModelId(state.model?.id ?? state.model?.name);
 
 		let content = withIcon(theme.icon.model, modelName);
+		const unavailableProfile = ctx.session.getUnavailableModelProfile?.();
+		if (unavailableProfile) {
+			content = `${theme.fg("warning", `profile unavailable: ${sanitizeStatusText(unavailableProfile)}`)} ${content}`;
+		}
 
 		if (ctx.session.isFastModeActive() && theme.icon.fast) {
 			content += ` ${theme.icon.fast}`;

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

@@ -60,6 +60,8 @@ export const __eventControllerPerfCounters = {
 const COMPLETION_NOTIFY_COMMAND_TIMEOUT_MS = 10_000;
 const TEXTLESS_LENGTH_WARNING =
 	'Response ended with stopReason "length" before producing visible text or a tool call. Check the model\'s output and context token limits (maxTokens in models.yml) or lower the reasoning level (/reasoning), then retry.';
+const TEXTLESS_INCOMPLETE_WARNING =
+	"Response ended before producing visible text or a tool call. See the provider diagnostic for the reason.";
 
 function isTextlessLengthStop(message: AssistantMessage | undefined): boolean {
 	return (
@@ -1090,7 +1092,7 @@ export class EventController {
 			event.stopReason !== "maintenance" &&
 			isTextlessLengthStop(lastAssistant)
 		) {
-			this.ctx.showWarning(TEXTLESS_LENGTH_WARNING);
+			this.ctx.showWarning(lastAssistant?.errorMessage ? TEXTLESS_INCOMPLETE_WARNING : TEXTLESS_LENGTH_WARNING);
 		}
 		this.sendCompletionNotification();
 		this.ctx.promptSuggestion?.onAgentEnd();
@@ -1372,15 +1374,20 @@ export class EventController {
 
 		const sessionName = this.ctx.sessionManager.getSessionName();
 		const textlessLengthStop = isTextlessLengthStop(last);
+		const incompleteTitle = last?.errorMessage ? "Response incomplete" : "Output limit reached";
 		const title = textlessLengthStop
 			? sessionName
-				? `${sessionName}: Output limit reached`
-				: "Output limit reached"
+				? `${sessionName}: ${incompleteTitle}`
+				: incompleteTitle
 			: sessionName
 				? `${sessionName}: Complete`
 				: "Complete";
 		const summary = summaryFromMessage(last, 1000);
-		const body = textlessLengthStop ? TEXTLESS_LENGTH_WARNING : (summary ?? "Complete");
+		const body = textlessLengthStop
+			? last?.errorMessage
+				? TEXTLESS_INCOMPLETE_WARNING
+				: TEXTLESS_LENGTH_WARNING
+			: (summary ?? "Complete");
 		const sessionManager = this.ctx.sessionManager as { getCwd?: () => string; getSessionId?: () => string };
 		const payload: CompletionNotifyPayload = {
 			type: "agent-turn-complete",