@gajae-code/coding-agent 0.1.1

package/dist/types/memory-backend/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Memory backend abstraction.
+ *
+ * Backends are mutually exclusive — `resolveMemoryBackend(settings)` returns
+ * exactly one. Implementations MUST be self-contained: they own the per-session
+ * state they create in `start()` and tear it down on `clear()`.
+ */
+import type { AgentMessage } from "@gajae-code/agent-core";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { HindsightSessionState } from "../hindsight/state";
+import type { AgentSession } from "../session/agent-session";
+export type MemoryBackendId = "off" | "local" | "hindsight";
+export interface MemoryBackendStartOptions {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    agentDir: string;
+    taskDepth: number;
+    parentHindsightSessionState?: HindsightSessionState;
+}
+export interface MemoryBackend {
+    readonly id: MemoryBackendId;
+    /**
+     * Wire any background work or session subscriptions for this backend.
+     *
+     * Called once per agent session at startup. Implementations MUST be
+     * non-throwing: failures should be logged and swallowed so a misconfigured
+     * memory backend cannot break the agent loop.
+     */
+    start(options: MemoryBackendStartOptions): void | Promise<void>;
+    /**
+     * Markdown injected as the system-prompt append section.
+     * Returned on every prompt rebuild via `refreshBaseSystemPrompt()`.
+     */
+    buildDeveloperInstructions(agentDir: string, settings: Settings, session?: AgentSession): Promise<string | undefined>;
+    /** Wipe all persisted state for this backend (slash `/memory clear`). */
+    clear(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /** Force consolidation/retain to happen now (slash `/memory enqueue`). */
+    enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /**
+     * Optional hook to inject a backend-specific block into the current turn's
+     * system prompt before the agent starts generating.
+     *
+     * This is the only place a backend can affect the very first answer of a
+     * fresh session. The returned text is appended to the already-built base
+     * system prompt for this turn only; callers may separately cache it and
+     * surface it through `buildDeveloperInstructions()` on later rebuilds.
+     */
+    beforeAgentStartPrompt?(session: AgentSession, promptText: string): Promise<string | undefined>;
+    /**
+     * Optional hook to splice extra context into a compaction summarization.
+     *
+     * Called from the compaction call site before the LLM summary is requested.
+     * Returning a string appends one entry to the compaction's `extraContext`
+     * list (which becomes part of the summarization prompt). Return `undefined`
+     * to inject nothing — the local backend takes this branch because its
+     * summary is already part of the system prompt.
+     */
+    preCompactionContext?(messages: AgentMessage[], settings: Settings, session?: AgentSession): Promise<string | undefined>;
+}

package/dist/types/modes/acp/acp-agent.d.ts

@@ -0,0 +1,61 @@
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModelRequest, type SetSessionModelResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+/**
+ * Delay between `session/new` (or `session/load` / `session/resume` /
+ * `unstable_session/fork`) returning and the agent firing the first
+ * notifications against the new session id. Mitigates Zed's
+ * `Received session notification for unknown session` race — see
+ * `#scheduleBootstrapUpdates`. Exported so the ACP test harness can
+ * wait past this guard without hard-coding the literal.
+ */
+export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+type CreateAcpSession = (cwd: string) => Promise<AgentSession>;
+/**
+ * Build an {@link ExtensionUIContext} that translates skill/extension UI
+ * requests into ACP elicitations against `connection` for the session
+ * returned by `getSessionId()`. The id is read lazily at each elicitation
+ * because `AgentSession.sessionId` is a getter over `sessionManager` state
+ * that mutates when an extension command calls `ctx.newSession` /
+ * `ctx.switchSession` — snapshotting it once at factory time would route
+ * later elicitations to the pre-switch id. Live reads keep the bridge
+ * symmetric with every other `sessionUpdate` call in this file
+ * (`record.session.sessionId` is always evaluated at emit time).
+ *
+ * The non-elicitation surface (custom components, editor, theming,
+ * terminal input) remains stubbed — ACP clients render those themselves
+ * or not at all. Capability gating respects the client's `initialize`
+ * advertisement.
+ */
+export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, clientCapabilities: ClientCapabilities | undefined): ExtensionUIContext;
+export declare class AcpAgent implements Agent {
+    #private;
+    constructor(connection: AgentSideConnection, createSession: CreateAcpSession, initialSession?: AgentSession);
+    setCancelCleanupTimeoutForTesting(timeoutMs: number): void;
+    initialize(params: InitializeRequest): Promise<InitializeResponse>;
+    authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
+    unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: {
+        sessionId: string;
+    }): Promise<void>;
+    extMethod(method: string, params: {
+        [key: string]: unknown;
+    }): Promise<{
+        [key: string]: unknown;
+    }>;
+    extNotification(_method: string, _params: {
+        [key: string]: unknown;
+    }): Promise<void>;
+    get signal(): AbortSignal;
+    get closed(): Promise<void>;
+}
+export {};

package/dist/types/modes/acp/acp-client-bridge.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ACP-side `ClientBridge` implementation. Wraps `AgentSideConnection` so the
+ * `read`/`write`/`bash`/`edit` tools (and the permission gate in
+ * `AgentSession`) can route through the client when it advertises the
+ * relevant capabilities at `initialize` time.
+ */
+import type { AgentSideConnection, ClientCapabilities } from "@agentclientprotocol/sdk";
+import type { ClientBridge } from "../../session/client-bridge";
+export declare function createAcpClientBridge(connection: AgentSideConnection, sessionId: string, clientCapabilities: ClientCapabilities | undefined): ClientBridge;

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

@@ -0,0 +1,32 @@
+import type { SessionNotification, SessionUpdate, ToolKind } from "@agentclientprotocol/sdk";
+import type { AgentSessionEvent } from "../../session/agent-session";
+interface MessageProgress {
+    textEmitted: boolean;
+    thoughtEmitted: boolean;
+}
+interface AcpEventMapperOptions {
+    getMessageId?: (message: unknown) => string | undefined;
+    getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+    getToolArgs?: (toolCallId: string) => unknown;
+    /**
+     * Session cwd. Tool call locations sent to ACP clients must be absolute
+     * (the editor host needs them to open or focus files). When provided,
+     * the mapper resolves raw `path`/`file`/etc. args against this cwd
+     * before emitting `ToolCallLocation` entries.
+     */
+    cwd?: string;
+}
+export declare function mapToolKind(toolName: string): ToolKind;
+export declare function mapAgentSessionEventToAcpSessionUpdates(event: AgentSessionEvent, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
+export declare function buildToolCallStartUpdate(input: {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    intent?: string;
+    cwd?: string;
+    status?: "pending" | "completed";
+}): SessionUpdate;
+export declare function normalizeReplayToolArguments(value: unknown): {
+    args: unknown;
+};
+export {};

package/dist/types/modes/acp/acp-mode.d.ts

@@ -0,0 +1,5 @@
+import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
+import type { AgentSession } from "../../session/agent-session";
+export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
+export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AgentSideConnection;
+export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never>;

package/dist/types/modes/acp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./acp-agent";
+export * from "./acp-mode";

package/dist/types/modes/acp/terminal-auth.d.ts

@@ -0,0 +1,6 @@
+export declare const ACP_TERMINAL_AUTH_FLAG = "--acp-terminal-auth";
+export interface AcpTerminalAuthArgs {
+    args: string[];
+    terminalAuth: boolean;
+}
+export declare function prepareAcpTerminalAuthArgs(rawArgs: readonly string[]): AcpTerminalAuthArgs;

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -0,0 +1,21 @@
+import { Container } from "@gajae-code/tui";
+import type { ModelRegistry } from "../../config/model-registry";
+import { Settings } from "../../config/settings";
+interface AgentDashboardModelContext {
+    modelRegistry?: ModelRegistry;
+    activeModelPattern?: string;
+    defaultModelPattern?: string;
+}
+export declare class AgentDashboard extends Container {
+    #private;
+    private readonly cwd;
+    private readonly settings;
+    private readonly terminalHeight;
+    private readonly modelContext;
+    onClose?: () => void;
+    onRequestRender?: () => void;
+    private constructor();
+    static create(cwd: string, settings?: Settings | null, terminalHeight?: number, modelContext?: AgentDashboardModelContext): Promise<AgentDashboard>;
+    handleInput(data: string): void;
+}
+export {};

package/dist/types/modes/components/assistant-message.d.ts

@@ -0,0 +1,16 @@
+import type { AssistantMessage, ImageContent, Usage } from "@gajae-code/ai";
+import { Container } from "@gajae-code/tui";
+/**
+ * Component that renders a complete assistant message
+ */
+export declare class AssistantMessageComponent extends Container {
+    #private;
+    private hideThinkingBlock;
+    private readonly onImageUpdate?;
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined);
+    invalidate(): void;
+    setHideThinkingBlock(hide: boolean): void;
+    setToolResultImages(toolCallId: string, images: ImageContent[]): void;
+    setUsageInfo(usage: Usage): void;
+    updateContent(message: AssistantMessage): void;
+}

package/dist/types/modes/components/bash-execution.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Component for displaying bash command execution with streaming output.
+ */
+import { Container, type TUI } from "@gajae-code/tui";
+import type { TruncationMeta } from "../../tools/output-meta";
+export declare class BashExecutionComponent extends Container {
+    #private;
+    private readonly command;
+    constructor(command: string, ui: TUI, excludeFromContext?: boolean);
+    /**
+     * Set whether the output is expanded (shows full output) or collapsed (preview only).
+     */
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+    }): void;
+    render(width: number): string[];
+    /**
+     * Get the raw output for creating BashExecutionMessage.
+     */
+    getOutput(): string;
+    /**
+     * Get the command that was executed.
+     */
+    getCommand(): string;
+}

package/dist/types/modes/components/bordered-loader.d.ts

@@ -0,0 +1,11 @@
+import { Container, type TUI } from "@gajae-code/tui";
+import type { Theme } from "../../modes/theme/theme";
+/** Loader wrapped with borders for hook UI */
+export declare class BorderedLoader extends Container {
+    #private;
+    constructor(tui: TUI, theme: Theme, message: string);
+    get signal(): AbortSignal;
+    set onAbort(fn: (() => void) | undefined);
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/modes/components/branch-summary-message.d.ts

@@ -0,0 +1,13 @@
+import { Box } from "@gajae-code/tui";
+import type { BranchSummaryMessage } from "../../session/messages";
+/**
+ * Component that renders a branch summary message with collapsed/expanded state.
+ * Uses same background color as hook messages for visual consistency.
+ */
+export declare class BranchSummaryMessageComponent extends Box {
+    #private;
+    private readonly message;
+    constructor(message: BranchSummaryMessage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/btw-panel.d.ts

@@ -0,0 +1,16 @@
+import { Container, type TUI } from "@gajae-code/tui";
+interface BtwPanelComponentOptions {
+    question: string;
+    tui: TUI;
+}
+export declare class BtwPanelComponent extends Container {
+    #private;
+    constructor(options: BtwPanelComponentOptions);
+    appendText(delta: string): void;
+    setAnswer(text: string): void;
+    markComplete(): void;
+    markAborted(): void;
+    markError(message: string): void;
+    close(): void;
+}
+export {};

package/dist/types/modes/components/compaction-summary-message.d.ts

@@ -0,0 +1,13 @@
+import { Box } from "@gajae-code/tui";
+import type { CompactionSummaryMessage } from "../../session/messages";
+/**
+ * Component that renders a compaction message with collapsed/expanded state.
+ * Uses same background color as hook messages for visual consistency.
+ */
+export declare class CompactionSummaryMessageComponent extends Box {
+    #private;
+    private readonly message;
+    constructor(message: CompactionSummaryMessage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/countdown-timer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reusable countdown timer for dialog components.
+ */
+import type { TUI } from "@gajae-code/tui";
+export declare class CountdownTimer {
+    #private;
+    private tui;
+    private onTick;
+    private onExpire;
+    constructor(timeoutMs: number, tui: TUI | undefined, onTick: (seconds: number) => void, onExpire: () => void);
+    /** Reset the countdown to its initial value */
+    reset(): void;
+    dispose(): void;
+}

package/dist/types/modes/components/custom-editor.d.ts

@@ -0,0 +1,47 @@
+import { Editor, type KeyId } from "@gajae-code/tui";
+import type { AppKeybinding } from "../../config/keybindings";
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+/**
+ * Custom editor that handles configurable app-level shortcuts for coding-agent.
+ */
+export declare class CustomEditor extends Editor {
+    #private;
+    onEscape?: () => void;
+    shouldBypassAutocompleteOnEscape?: () => boolean;
+    onClear?: () => void;
+    onExit?: () => void;
+    onCycleThinkingLevel?: () => void;
+    onCycleModelForward?: () => void;
+    onCycleModelBackward?: () => void;
+    onSelectModel?: () => void;
+    onExpandTools?: () => void;
+    onToggleThinking?: () => void;
+    onExternalEditor?: () => void;
+    onHistorySearch?: () => void;
+    onSuspend?: () => void;
+    onShowHotkeys?: () => void;
+    onSelectModelTemporary?: () => void;
+    /** Called when the configured copy-prompt shortcut is pressed. */
+    onCopyPrompt?: () => void;
+    /** Called when the configured image-paste shortcut is pressed. */
+    onPasteImage?: () => Promise<boolean>;
+    /** Called when the configured dequeue shortcut is pressed. */
+    onDequeue?: () => void;
+    /** Called when Caps Lock is pressed. */
+    onCapsLock?: () => void;
+    setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
+    /**
+     * Register a custom key handler. Extensions use this for shortcuts.
+     */
+    setCustomKeyHandler(key: KeyId, handler: () => void): void;
+    /**
+     * Remove a custom key handler.
+     */
+    removeCustomKeyHandler(key: KeyId): void;
+    /**
+     * Clear all custom key handlers.
+     */
+    clearCustomKeyHandlers(): void;
+    handleInput(data: string): void;
+}
+export {};

package/dist/types/modes/components/custom-message.d.ts

@@ -0,0 +1,15 @@
+import { Container } from "@gajae-code/tui";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import type { CustomMessage } from "../../session/messages";
+/**
+ * Component that renders a custom message entry from extensions.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class CustomMessageComponent extends Container {
+    #private;
+    private readonly message;
+    private readonly customRenderer?;
+    constructor(message: CustomMessage<unknown>, customRenderer?: MessageRenderer | undefined);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/diff.d.ts

@@ -0,0 +1,11 @@
+export interface RenderDiffOptions {
+    /** File path used to resolve indentation (.editorconfig + defaults) */
+    filePath?: string;
+}
+/**
+ * Render a diff string with colored lines and intra-line change highlighting.
+ * - Context lines: dim/gray
+ * - Removed lines: red, with inverse on changed tokens
+ * - Added lines: green, with inverse on changed tokens
+ */
+export declare function renderDiff(diffText: string, options?: RenderDiffOptions): string;

package/dist/types/modes/components/dynamic-border.d.ts

@@ -0,0 +1,14 @@
+import type { Component } from "@gajae-code/tui";
+/**
+ * Dynamic border component that adjusts to viewport width.
+ *
+ * Note: When used from hooks loaded via jiti, the global `theme` may be undefined
+ * because jiti creates a separate module cache. Always pass an explicit color
+ * function when using DynamicBorder in components exported for hook use.
+ */
+export declare class DynamicBorder implements Component {
+    #private;
+    constructor(color?: (str: string) => string);
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/eval-execution.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Component for displaying user-initiated eval execution with streaming output.
+ * Shares the same kernel session as the agent's eval tool.
+ */
+import { Container, type TUI } from "@gajae-code/tui";
+import type { TruncationMeta } from "../../tools/output-meta";
+export type EvalExecutionLanguage = "python" | "js";
+export declare class EvalExecutionComponent extends Container {
+    #private;
+    private readonly code;
+    private readonly excludeFromContext;
+    private readonly language;
+    constructor(code: string, ui: TUI, excludeFromContext?: boolean, language?: EvalExecutionLanguage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+    }): void;
+    getOutput(): string;
+    getCode(): string;
+}

package/dist/types/modes/components/execution-shared.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared rendering primitives for bash/eval execution components.
+ *
+ * Each helper isolates a piece of structure both components share verbatim
+ * (frame layout, collapsed preview, post-run status line). Differences in
+ * how each component prepares its header, output lines, or sixel masking
+ * stay in their respective files.
+ */
+import { type Component, Container, Loader, Text, type TUI } from "@gajae-code/tui";
+import { type TruncationMeta } from "../../tools/output-meta";
+export type ExecutionStatus = "running" | "complete" | "cancelled" | "error";
+/** Theme color keys valid for an execution frame. */
+export type ExecutionColorKey = "dim" | "bashMode" | "pythonMode";
+/**
+ * Build the spacer + top border + content container + bottom border scaffold
+ * that bash and eval execution components share. The caller appends the
+ * header (command vs `>>>` prompt) and the returned loader to
+ * `contentContainer` so per-mode order is preserved.
+ */
+export declare function buildExecutionFrame(parent: Container, ui: TUI, colorKey: ExecutionColorKey): {
+    contentContainer: Container;
+    loader: Loader;
+};
+/**
+ * Wrap a styled preview block in a render-time visual-line truncator.
+ * Recomputed per render width so wrapping stays in sync with terminal size.
+ */
+export declare function createCollapsedPreview(previewText: string, previewLines: number): Component;
+/**
+ * Build the post-run status block (hidden-line hint, exit/cancel marker,
+ * truncation notice). Returns undefined when there is nothing to display so
+ * callers can skip appending a stray Text child.
+ */
+export declare function buildStatusFooter(opts: {
+    status: ExecutionStatus;
+    exitCode: number | undefined;
+    truncation: TruncationMeta | undefined;
+    hiddenLineCount: number;
+    /** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */
+    suppressHiddenCount?: boolean;
+}): Text | undefined;
+/**
+ * Derive the post-run status from an exit code + cancellation flag using the
+ * same precedence both execution components apply.
+ */
+export declare function resolveExecutionStatus(exitCode: number | undefined, cancelled: boolean): ExecutionStatus;

package/dist/types/modes/components/extensions/extension-dashboard.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ExtensionDashboard - Tabbed layout for the Extension Control Center.
+ *
+ * Layout:
+ * - Top: Horizontal tab bar for provider selection
+ * - Body: 2-column grid (inventory list | preview panel)
+ *
+ * Navigation:
+ * - TAB/Shift+TAB: Cycle through provider tabs
+ * - Up/Down/j/k: Navigate list
+ * - Space: Toggle selected item (or master switch)
+ * - Esc: Close dashboard (clears search first if active)
+ */
+import { Container } from "@gajae-code/tui";
+import { Settings } from "../../../config/settings";
+export declare class ExtensionDashboard extends Container {
+    #private;
+    private readonly cwd;
+    private readonly settings;
+    private readonly terminalHeight;
+    onClose?: () => void;
+    onRequestRender?: () => void;
+    private constructor();
+    static create(cwd: string, settings?: Settings | null, terminalHeight?: number): Promise<ExtensionDashboard>;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/extensions/extension-list.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ExtensionList - Inventory list with Master Switch and fuzzy search.
+ *
+ * When viewing a specific provider (not "ALL"), Row #0 is the Master Switch
+ * that toggles the entire provider. All items below are dimmed when the
+ * master switch is off.
+ */
+import { type Component } from "@gajae-code/tui";
+import type { Extension, ExtensionKind } from "./types";
+export interface ExtensionListCallbacks {
+    /** Called when selection changes */
+    onSelectionChange?: (extension: Extension | null) => void;
+    /** Called when extension is toggled */
+    onToggle?: (extensionId: string, enabled: boolean) => void;
+    /** Called when master switch is toggled */
+    onMasterToggle?: (providerId: string) => void;
+    /** Provider ID for master switch (null = no master switch) */
+    masterSwitchProvider?: string | null;
+}
+export declare class ExtensionList implements Component {
+    #private;
+    private extensions;
+    private readonly callbacks;
+    constructor(extensions: Extension[], callbacks?: ExtensionListCallbacks, maxVisible?: number);
+    setMaxVisible(maxVisible: number): void;
+    setExtensions(extensions: Extension[]): void;
+    setFocused(focused: boolean): void;
+    setMasterSwitchProvider(providerId: string | null): void;
+    getSearchQuery(): string;
+    resetSelection(): void;
+    getSelectedExtension(): Extension | null;
+    /** Get the currently selected kind header (for preview purposes) */
+    getSelectedKind(): ExtensionKind | null;
+    setSearchQuery(query: string): void;
+    clearSearch(): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/extensions/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extension Control Center exports.
+ */
+export * from "./extension-dashboard";
+export * from "./extension-list";
+export * from "./inspector-panel";
+export * from "./state-manager";
+export * from "./types";

package/dist/types/modes/components/extensions/inspector-panel.d.ts

@@ -0,0 +1,8 @@
+import { type Component } from "@gajae-code/tui";
+import type { Extension } from "./types";
+export declare class InspectorPanel implements Component {
+    #private;
+    setExtension(extension: Extension | null): void;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/extensions/state-manager.d.ts

@@ -0,0 +1,50 @@
+import type { DashboardState, Extension, FlatTreeItem, ProviderTab, TreeNode } from "./types";
+/**
+ * Settings manager interface for granular toggle persistence.
+ */
+export interface ExtensionSettingsManager {
+    getDisabledExtensions(): string[];
+    setDisabledExtensions(ids: string[]): void;
+}
+/**
+ * Load all extensions from all capabilities.
+ */
+export declare function loadAllExtensions(cwd?: string, disabledIds?: string[]): Promise<Extension[]>;
+/**
+ * Build sidebar tree from extensions.
+ * Groups by provider → kind.
+ */
+export declare function buildSidebarTree(extensions: Extension[]): TreeNode[];
+/**
+ * Flatten tree for keyboard navigation.
+ */
+export declare function flattenTree(tree: TreeNode[]): FlatTreeItem[];
+/**
+ * Apply fuzzy filter to extensions.
+ */
+export declare function applyFilter(extensions: Extension[], query: string): Extension[];
+/**
+ * Build provider tabs from extensions.
+ */
+export declare function buildProviderTabs(extensions: Extension[]): ProviderTab[];
+/**
+ * Filter extensions by provider tab.
+ */
+export declare function filterByProvider(extensions: Extension[], providerId: string): Extension[];
+/**
+ * Apply setting-backed item disable overrides to an existing dashboard state.
+ * This gives the UI immediate feedback while the full capability refresh runs.
+ */
+export declare function applyDisabledExtensionsToState(state: DashboardState, disabledIds: string[]): DashboardState;
+/**
+ * Create initial dashboard state.
+ */
+export declare function createInitialState(cwd?: string, disabledIds?: string[]): Promise<DashboardState>;
+/**
+ * Toggle provider enabled state.
+ */
+export declare function toggleProvider(providerId: string): boolean;
+/**
+ * Refresh state after toggle.
+ */
+export declare function refreshState(state: DashboardState, cwd?: string, disabledIds?: string[]): Promise<DashboardState>;