@gajae-code/coding-agent 0.13.2 → 0.14.0

package/dist/types/modes/acp/abort-scope.d.ts

@@ -0,0 +1,13 @@
+import type { AbortScope } from "../../sdk/host/control/operations";
+/**
+ * Resolves the C04 terminal-abort scope for an ACP `session/cancel`. Client
+ * metadata is authoritative; the process environment is only a fallback when
+ * that field is absent. Both default to `"turn"` so an external client that
+ * ends a turn only stops that turn, matching the SDK `turn.abort` default and
+ * other ACP clients' cancel behavior; a client that also wants exact owned
+ * subagents and background tasks stopped opts in per request with
+ * `_meta.gjc.abortScope: "owned"` (or process-wide with
+ * `GJC_ACP_ABORT_SCOPE=owned`). Paseo keeps owned cancels through its provider
+ * config `env: { "GJC_ACP_ABORT_SCOPE": "owned" }` without source changes.
+ */
+export declare function resolveAcpAbortScope(meta: unknown, env?: NodeJS.ProcessEnv): AbortScope;

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

@@ -1,4 +1,4 @@
-import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AvailableCommand, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, 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 SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AvailableCommand, type CancelNotification, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, 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 SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
 import { type AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter } from "../../sdk/acp";
 import { type PromptWatchdogClock } from "../../sdk/prompt-watchdog";
 import type { AcpStartupOptions } from "./startup-options";
@@ -240,6 +240,11 @@ export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQu
         currentModeId: string;
     };
 };
+/** Recognize a canonical ACP skill command only when it is the complete, single text prompt. */
+export declare function acpSkillInvocation(blocks: PromptRequest["prompt"]): {
+    name: string;
+    args: string;
+} | undefined;
 /** Convert every ACP prompt block the agent advertises without silently discarding context. */
 export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
     text: string;
@@ -295,9 +300,7 @@ export declare class AcpAgent implements Agent {
     setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
     setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
     prompt(params: PromptRequest): Promise<PromptResponse>;
-    cancel(params: {
-        sessionId: string;
-    }): Promise<void>;
+    cancel(params: CancelNotification): Promise<void>;
     extMethod(method: string, params: JsonObject): Promise<JsonObject>;
     extNotification(_method: string, _params: JsonObject): Promise<void>;
     get signal(): AbortSignal;

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

@@ -0,0 +1,44 @@
+/**
+ * CustomizationDashboard — the umbrella local-customization home opened by the
+ * `/extensions` slash command (issue #4291).
+ *
+ * This is a standalone state model and component tree around local
+ * Skills/Hooks/MCPs/Import. It is intentionally NOT built on the
+ * provider/extension-module ExtensionDashboard; the two surfaces share only
+ * generic TUI primitives (Container, Text, SelectList, DynamicBorder).
+ *
+ * The scope switch is a real management boundary: each list only shows rows
+ * persisted at the active scope, and mutations refuse rows from the other
+ * scope. All dynamic text is sanitized before rendering.
+ *
+ * Layout (narrow-terminal safe):
+ *   title: /extensions — Configure skills, hooks, and MCPs.
+ *   scope badge (Project .gjc / Global .gjc) — `s` switches
+ *   section tabs: Skills | Hooks | MCPs — left/right switch
+ *   inventory rows for the active section + scope with status + provenance
+ *   footer key hints
+ */
+import { Container } from "@gajae-code/tui";
+import { type CustomizationInventory } from "../../../customization/inventory";
+import { type CustomizationSurface, type GjcScope } from "../../../customization/types";
+/** Minimal settings slice the dashboard reads and writes. */
+export interface CustomizationSettingsSlice {
+    get(key: string): unknown;
+    set?(key: string, value: unknown): void;
+}
+export declare class CustomizationDashboard extends Container {
+    #private;
+    /** Called when the dashboard wants to close (Esc / q / interrupt). */
+    onClose: (() => void) | undefined;
+    /** Called whenever the dashboard needs a re-render. */
+    onRequestRender: (() => void) | undefined;
+    /** Use `create()` — async inventory load runs before chrome construction. */
+    constructor(cwd: string, settings: CustomizationSettingsSlice | undefined, homeDir: string | undefined);
+    static create(cwd: string, settings?: CustomizationSettingsSlice, homeDir?: string): Promise<CustomizationDashboard>;
+    get scope(): GjcScope;
+    get section(): CustomizationSurface;
+    /** Current inventory snapshot (test-visible). */
+    get inventory(): CustomizationInventory;
+    handleInput(keyData: string): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/customization/import-wizard.d.ts

@@ -0,0 +1,21 @@
+import { Container } from "@gajae-code/tui";
+import type { GjcScope, ImportPreview, ImportResult } from "../../../customization/types";
+type WizardStep = "product" | "sourceScope" | "surfaces" | "collision" | "preview" | "result";
+export declare class ImportWizard extends Container {
+    #private;
+    /** Called when the wizard finishes or is cancelled; `applied` is true only when an import succeeded. */
+    onClose: ((applied: boolean) => void) | undefined;
+    onRequestRender: (() => void) | undefined;
+    constructor(cwd: string, destinationScope: GjcScope, homeDir?: string);
+    /** Current step (test-visible). */
+    get step(): WizardStep;
+    /** Last built preview DTO — redacted and serialization-safe (test-visible). */
+    get preview(): ImportPreview | null;
+    /** Last apply result (test-visible). */
+    get result(): ImportResult | null;
+    /** Whether the wizard currently shows an attached selection list (test-visible). */
+    get hasVisibleSelector(): boolean;
+    handleInput(keyData: string): void;
+    render(width: number): string[];
+}
+export {};

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

@@ -0,0 +1 @@
+export * from "./customization-dashboard";

package/dist/types/modes/components/dynamic-theme-text.d.ts

@@ -0,0 +1,9 @@
+import { type Component } from "@gajae-code/tui";
+/** Text whose styling is resolved at render time so live theme previews recolor open overlays. */
+export declare class DynamicThemeText implements Component {
+    #private;
+    private readonly getText;
+    constructor(getText: () => string);
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/gajae-pet-widget.d.ts

@@ -2,11 +2,7 @@ import { type Component, type Container, type PetMode, type PetSkinId, type TUI
 import type { CustomEditor } from "./custom-editor";
 /** Re-exported from the tui skin registry so widget-relative imports stay valid. */
 export type { PetMode, PetSkinId };
-/**
- * Wraps the composer editor, reserving a right-side area beside it where the
- * real-pixel pet is drawn. The editor just renders narrower; the pet pixels
- * are emitted separately as an absolute-positioned overlay.
- */
+/** Reserve a right-side area beside the composer where the pixel pet is drawn. */
 export declare class PetFramedEditor implements Component {
     #private;
     constructor(editor: CustomEditor);
@@ -15,20 +11,7 @@ export declare class PetFramedEditor implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
-/**
- * The gajae pet: a 16x16 real-pixel sprite living in a reserved area beside
- * the composer. It is nearest-neighbor scaled to the two terminal rows occupied
- * by an empty one-line composer and lifted one row so its feet meet the input
- * box's bottom edge.
- *
- * Rendering has two paths that share one payload builder:
- * - a post-render emitter re-draws the sprite after every TUI write (line
- *   renders clear the pet cells, so the overlay must be re-applied), and
- * - frame advances write the payload directly to the terminal, because the
- *   TUI skips writes entirely when no component line changed.
- *
- * Requires a sixel- or kitty-graphics terminal (`pixelProtocol()`).
- */
+/** The gajae pet pixel sprite and protocol-specific rendering lifecycle. */
 export declare class GajaePetWidget {
     #private;
     constructor(options: {
@@ -37,24 +20,19 @@ export declare class GajaePetWidget {
         editorContainer: Container;
         floorContainer: Container;
         isWorking: () => boolean;
-        /** Rows rendered below the composer box (pet floor + hook widgets). */
         getComposerBottomOffset: () => number;
+        syncManagedItermCursor: (row: number, column: number) => Promise<boolean>;
         forcePixelProtocol?: "sixel" | "kitty";
-        /** Random [min, max] ms between auto-flexes; null disables. */
         autoFlexGapMs?: [number, number] | null;
     });
-    /** Protocol available for the real-pixel pet, if any. */
-    static pixelProtocol(): "sixel" | "kitty" | null;
+    static pixelProtocol(): "sixel" | "kitty" | "iterm" | null;
     get mode(): PetMode;
     get isFlexing(): boolean;
     setMode(mode: PetMode): void;
-    /** Live preview during a selector: change the sprite without re-mounting the
-     *  composer editor (that would tear down the open overlay). After a short idle
-     *  eye-roll it fires the signature burst once (RedGajae flex, BlueGajae para-para
-     *  then sob) so the selector demos the animation instead of waiting the random gap. */
+    suspendItermCapability(): Promise<void>;
     previewMode(mode: PetMode): void;
     commitPreviewMode(mode: PetMode): void;
     dispose(): void;
-    /** Re-mount the composer editor (framed when a skin is active) after an overlay. */
+    disposeAsync(): Promise<void>;
     remountComposer(): void;
 }

package/dist/types/modes/components/irc-sidebar.d.ts

@@ -77,6 +77,7 @@ export declare class IrcSplitViewComponent implements ViewportAnchorProvider {
     private readonly ledger;
     private readonly componentTheme;
     constructor(leftPane: Component, ledger: IrcObservationLedger, componentTheme: IrcSidebarThemeSource);
+    getRenderRevision(): bigint;
     get visible(): boolean;
     effectiveSidebarVisible(width?: number): boolean;
     setVisible(visible: boolean): void;

package/dist/types/modes/components/iterm-pet-transport.d.ts

@@ -0,0 +1,122 @@
+export declare const PET_CAPABILITY_DRAIN_MAX_MS = 100;
+export declare const PET_CAPABILITY_QUIESCENCE_MS = 25;
+export declare const PET_CAPABILITY_QUERY_TIMEOUT_MS = 1000;
+export declare const PET_TOPOLOGY_POLL_MS = 250;
+export type PetTransportMode = "direct" | "managed";
+export type PetUnavailableReason = "not-iterm2" | "tty-unavailable" | "missing-f" | "invalid-f" | "probe-timeout" | "topology-ineligible" | "topology-lost" | "zero-client-recovery" | "cleanup-failed";
+export type PetTransportAvailability = Readonly<{
+    available: boolean;
+    mode: PetTransportMode;
+    reason?: PetUnavailableReason;
+    epoch: number;
+}>;
+export type PetTransportClock = Readonly<{
+    now(): number;
+    setTimeout(callback: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}>;
+export type PetTransportInput = Readonly<{
+    drain(maxMs: number, quiescenceMs: number): Promise<void>;
+    onData(callback: (data: Uint8Array | string) => PetInputResult | undefined): () => void;
+}>;
+export type PetInputResult = Readonly<{
+    consume?: true;
+    data?: string;
+}>;
+export type NativePetUi = Readonly<{
+    drainPetProbeInput?(maxMs: number, quiescenceMs: number): Promise<void>;
+    drainInput(maxMs: number, quiescenceMs: number): Promise<void>;
+    addInputListener(callback: (data: string | Uint8Array) => unknown): () => void;
+    submitTerminalOutput(request: Readonly<{
+        operation: Readonly<{
+            type: "raster-probe";
+            bytes: Uint8Array;
+        }>;
+    }>): Promise<Readonly<{
+        status?: string;
+        written?: number;
+    }>>;
+    notifyTerminalLifecycle(event: Readonly<{
+        kind: "availability-restored" | "explicit-cleanup";
+        source: "transport";
+        terminalGeneration: number;
+    }>): Promise<unknown>;
+    readonly terminalGeneration: number;
+}>;
+export type PetTransportOutput = Readonly<{
+    write(bytes: Uint8Array): Promise<Readonly<{
+        status: "written" | "failed";
+    }>>;
+    notifyLifecycle?(event: Readonly<{
+        kind: "availability-restored" | "explicit-cleanup";
+        terminalGeneration: number;
+    }>): Promise<unknown>;
+}>;
+export type PetTmuxResult = Readonly<{
+    status: number;
+    stdout: string;
+    stderr?: string;
+}>;
+export type PetTmuxRunner = (argv: readonly string[]) => Promise<PetTmuxResult | string>;
+export type PetTmuxTopology = Readonly<{
+    clients: number;
+    paneId?: string;
+    ownedPaneId?: string;
+    clientId?: string;
+    clientVersion?: string;
+}>;
+export declare function hasItermFileCapability(v: Uint8Array | string): boolean;
+export declare function consumeCapabilityInput(callback: (data: Uint8Array | string) => void): (data: string | Uint8Array) => PetInputResult | undefined;
+export declare function capabilityProbe(): NodeJS.NonSharedUint8Array;
+export declare function isItermCandidate(env?: NodeJS.ProcessEnv, tty?: boolean): boolean;
+export declare function createNativePetTransport(o: {
+    ui: NativePetUi;
+    env?: NodeJS.ProcessEnv;
+    topology?: () => Promise<PetTmuxTopology>;
+}): ItermPetTransport | undefined;
+export declare class ItermPetTransport {
+    #private;
+    constructor(o: Readonly<{
+        mode?: PetTransportMode;
+        ttyCandidate?: boolean;
+        clock: PetTransportClock;
+        input: PetTransportInput;
+        output: PetTransportOutput;
+        tmux?: PetTmuxRunner;
+        ownedPaneId?: string;
+        paneId?: string;
+        sessionTarget?: string;
+        topology?: () => Promise<PetTmuxTopology>;
+        expectedClientId?: string;
+    }>);
+    get availability(): {
+        available: boolean;
+        mode: PetTransportMode;
+        reason: PetUnavailableReason | undefined;
+        epoch: number;
+    };
+    refreshManagedClient(row: number, column: number): Promise<boolean>;
+    subscribe(cb: (a: PetTransportAvailability) => void): () => boolean;
+    probe(): Promise<Readonly<{
+        available: boolean;
+        mode: PetTransportMode;
+        reason?: PetUnavailableReason;
+        epoch: number;
+    }>>;
+    retry(): Promise<Readonly<{
+        available: boolean;
+        mode: PetTransportMode;
+        reason?: PetUnavailableReason;
+        epoch: number;
+    }>>;
+    revoke(reason?: PetUnavailableReason): Promise<PetTransportAvailability>;
+    inspectManagedTopology(): Promise<Readonly<{
+        available: boolean;
+        mode: PetTransportMode;
+        reason?: PetUnavailableReason;
+        epoch: number;
+    }>>;
+    startManagedPolling(): void;
+    stopManagedPolling(): void;
+    dispose(): Promise<void>;
+}

package/dist/types/modes/components/oauth-selector.d.ts

@@ -1,16 +1,22 @@
+import type { AuthCredentialSelector, CredentialRemovalTarget } from "@gajae-code/ai/core";
 import { Container } from "@gajae-code/tui";
 import type { AuthStorage } from "../../session/auth-storage";
 import type { ImportableCredential } from "../../setup/credential-import";
-/**
- * Component that renders an OAuth provider selector.
- */
+export interface OAuthSelectorAccountOptions {
+    accountProviderId?: string;
+    onAccountSelect?: (selector: AuthCredentialSelector) => void | Promise<void>;
+    onAutoSelect?: () => void | Promise<void>;
+    onAddAccount?: () => void | Promise<void>;
+    onAccountRemove?: (targets: readonly CredentialRemovalTarget[]) => void | Promise<void>;
+}
+/** Component that renders an OAuth provider selector or a provider-scoped account selector. */
 export declare class OAuthSelectorComponent extends Container {
     #private;
     constructor(mode: "login" | "logout", authStorage: AuthStorage, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
         validateAuth?: (providerId: string) => Promise<boolean>;
         requestRender?: () => void;
         externalCredentialCandidates?: ImportableCredential[];
-    });
+    } & Partial<OAuthSelectorAccountOptions>);
     stopValidation(): void;
     dispose(): void;
     handleInput(keyData: string): void;

package/dist/types/modes/components/pet-capability.d.ts

@@ -1,34 +1,20 @@
 import { type SelectItem } from "@gajae-code/tui";
-export type PetPixelProtocol = "sixel" | "kitty";
+import type { PetTransportAvailability } from "./iterm-pet-transport";
+export type PetPixelProtocol = "sixel" | "kitty" | "iterm";
 export declare const PET_UNAVAILABLE_DESCRIPTION = "Unavailable: requires compatible Kitty or Sixel overlay rendering";
 export declare const PET_SAVED_UNAVAILABLE_DESCRIPTION = "Saved, unavailable \u2014 requires compatible Kitty or Sixel overlay rendering";
 export declare const PET_UNAVAILABLE_WARNING = "\u26A0 Pets aren\u2019t available in this terminal. Its image support isn\u2019t compatible with Gajae Pet\u2019s overlay rendering yet. Try Kitty, Ghostty, WezTerm, or a terminal with compatible Sixel support.";
 export declare function getPetUnavailableWarning(env?: NodeJS.ProcessEnv): string;
+export declare function subscribeVerifiedItermPetAvailability(callback: (availability: PetTransportAvailability | undefined) => void): () => void;
+export declare function setVerifiedItermPetAvailability(availability: PetTransportAvailability | undefined): void;
+export declare function getItermPetAvailability(): PetTransportAvailability | undefined;
+export declare function getVerifiedItermPetAvailability(): PetTransportAvailability | undefined;
+export declare function getItermPetUnavailableReason(): string | undefined;
 export declare function getPetPixelProtocol(): PetPixelProtocol | null;
 export declare function isPetAvailable(): boolean;
 export declare function createPetSelectItems(options: ReadonlyArray<SelectItem>, currentValue: string, available: boolean): SelectItem[];
-/**
- * Grace period before declaring the terminal pet-incapable at startup. The
- * asynchronous Sixel capability probe starts inside `TUI.start()` and answers
- * within its own 250 ms deadline; this margin covers probe scheduling so a
- * supported terminal is never told it is incompatible while the probe is
- * still in flight.
- */
 export declare const PET_CAPABILITY_SETTLE_MS = 1000;
-/**
- * Whether the asynchronous startup Sixel capability probe may still enable
- * graphics for this session, meaning current unavailability is not final.
- */
 export declare function isPetCapabilityProbePending(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
-/**
- * Deliver the pet-unavailable startup warning only once the capability
- * question is settled. With no probe pending, unavailability is final and
- * `onUnavailable` fires immediately. While a probe may still enable
- * graphics, the warning is deferred: a protocol-change event cancels it (the
- * saved pet re-applies through the existing subscription), and only the
- * settle deadline passing with the terminal still unavailable emits it.
- * Returns a disposer that cancels the pending decision.
- */
 export declare function warnWhenPetCapabilitySettled(options: {
     probePending: boolean;
     isAvailable?: () => boolean;

package/dist/types/modes/components/settings-selector.d.ts

@@ -52,6 +52,11 @@ export interface SettingsCallbacks {
     onThemePreview?: (theme: string) => void | Promise<void>;
     /** Called to restore the rendered theme when theme settings preview is cancelled */
     onThemePreviewCancel?: (theme: string) => void | Promise<void>;
+    /**
+     * Atomically apply and persist a theme selection. Returns false when the
+     * candidate could not be loaded, leaving the submenu open.
+     */
+    onThemeCommit?: (path: "theme.dark" | "theme.light", theme: string, previousTheme: string) => Promise<boolean>;
     /** Called to live-preview the gajae pet skin while browsing the pet setting. */
     onPetPreview?: (mode: string) => void;
     /**

package/dist/types/modes/components/status-line/gh.d.ts

@@ -1,5 +1,9 @@
 import { type RunGh } from "../../../utils/gh";
-export declare function lookupCurrentPr(runGh?: RunGh): Promise<{
+type CurrentPr = {
     number: number;
     url: string;
-} | null>;
+} | null;
+export declare function lookupCurrentPr(runGh?: RunGh): Promise<CurrentPr>;
+export declare function lookupCurrentPrCached(cacheKey: string, runGh?: RunGh, now?: () => number): Promise<CurrentPr>;
+export declare function clearCurrentPrCache(): void;
+export {};

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -2,7 +2,7 @@ import { type Component, type TUI } from "@gajae-code/tui";
 import { KeybindingsManager } from "../../config/keybindings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
 import { type Theme } from "../../modes/theme/theme";
-import { type InteractiveModeContext } from "../../modes/types";
+import type { InteractiveModeContext } from "../../modes/types";
 export declare class ExtensionUiController {
     #private;
     private ctx;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -5,7 +5,7 @@ import { type InteractiveModeContext, type OAuthSelectorOptions } from "../../mo
 import { getCurrentTelegramActivationMarker, getNotificationConfig, maskToken } from "../../sdk/bus/config";
 import { type NotificationProviderRuntimeAuthority, proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
 import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
-import { ensureTelegramDaemonRunningDetailed, readNotificationRootRegistration, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { ensureTelegramDaemonRunningDetailed, resolveTelegramSetupPreflight } from "../../sdk/bus/telegram-daemon";
 import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
 import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
 import { type CommandPaletteAction } from "../components/command-palette";
@@ -51,13 +51,6 @@ export interface NotificationsEditorOperationDependencies {
     reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
     saveTelegramInactive: typeof saveTelegramInactive;
     removeTelegramConfiguration: typeof removeTelegramConfiguration;
-    readNotificationRootRegistration: typeof readNotificationRootRegistration;
-    unregisterNotificationRoot: typeof unregisterNotificationRoot;
-    stopTelegramDaemonIfRootRegistryFenceMatches(input: {
-        settings: Settings;
-        registryFingerprint: string;
-        stop: () => Promise<TelegramDaemonStopResult>;
-    }): Promise<boolean>;
     reloadTelegramDaemon(settings: Settings): Promise<{
         ok: boolean;
         message: string;
@@ -103,6 +96,12 @@ export declare class SelectorController {
      * Replaces /status with a unified view of all providers and extensions.
      */
     showExtensionsDashboard(): Promise<void>;
+    /**
+     * Show the `/extensions` umbrella local-customization dashboard (skills,
+     * hooks, MCPs, import) — a separate surface from the provider-focused
+     * Extension Control Center above (issue #4291).
+     */
+    showCustomizationDashboard(): Promise<void>;
     /**
      * Show the Agent Control Center dashboard.
      */

package/dist/types/modes/controllers/stt-controller.d.ts

@@ -7,7 +7,7 @@ interface SttEditor {
 }
 interface SttUi {
     getShowHardwareCursor(): boolean;
-    requestRender(): void;
+    requestLayoutRender(source?: string): void;
     setShowHardwareCursor(enabled: boolean): void;
 }
 export interface SttModeContext {

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

@@ -261,6 +261,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showPetSelector(): void;
     showHistorySearch(): Promise<void>;
     showExtensionsDashboard(): void;
+    showCustomizationDashboard(): void;
     showAgentsDashboard(): void;
     showModelSelector(options?: {
         temporaryOnly?: boolean;

package/dist/types/modes/theme/defaults/index.d.ts

@@ -526,6 +526,124 @@ export declare const defaultThemes: {
             preset: string;
         };
     };
+    ouroboros: {
+        $schema: string;
+        name: string;
+        vars: {
+            cyan: string;
+            blue: string;
+            green: string;
+            red: string;
+            yellow: string;
+            gray: string;
+            dimGray: string;
+            darkGray: string;
+            accent: string;
+            selectedBg: string;
+            userMsgBg: string;
+            toolPendingBg: string;
+            toolSuccessBg: string;
+            toolErrorBg: string;
+            customMsgBg: string;
+            abyss: string;
+            deepNavy: string;
+            mantle: string;
+            surface: string;
+            surfaceBright: string;
+            ouroTeal: string;
+            serpentGreen: string;
+            petLime: string;
+            ritualGold: string;
+            eyeGold: string;
+            coolScale: string;
+            foam: string;
+            mutedScale: string;
+            dimScale: string;
+            dangerRed: string;
+            diffRemovalRed: string;
+        };
+        colors: {
+            accent: string;
+            border: string;
+            borderAccent: string;
+            borderMuted: string;
+            success: string;
+            error: string;
+            warning: string;
+            muted: string;
+            dim: string;
+            text: string;
+            thinkingText: string;
+            selectedBg: string;
+            userMessageBg: string;
+            userMessageText: string;
+            customMessageBg: string;
+            customMessageText: string;
+            customMessageLabel: string;
+            toolPendingBg: string;
+            toolSuccessBg: string;
+            toolErrorBg: string;
+            toolTitle: string;
+            toolOutput: string;
+            mdHeading: string;
+            mdLink: string;
+            mdLinkUrl: string;
+            mdCode: string;
+            mdCodeBlock: string;
+            mdCodeBlockBorder: string;
+            mdQuote: string;
+            mdQuoteBorder: string;
+            mdHr: string;
+            mdListBullet: string;
+            toolDiffAdded: string;
+            toolDiffRemoved: string;
+            toolDiffContext: string;
+            syntaxComment: string;
+            syntaxKeyword: string;
+            syntaxFunction: string;
+            syntaxVariable: string;
+            syntaxString: string;
+            syntaxNumber: string;
+            syntaxType: string;
+            syntaxOperator: string;
+            syntaxPunctuation: string;
+            thinkingOff: string;
+            thinkingMinimal: string;
+            thinkingLow: string;
+            thinkingMedium: string;
+            thinkingHigh: string;
+            thinkingXhigh: string;
+            bashMode: string;
+            statusLineBg: string;
+            statusLineSep: string;
+            statusLineModel: string;
+            statusLinePath: string;
+            statusLineGitClean: string;
+            statusLineGitDirty: string;
+            statusLineContext: string;
+            statusLineSpend: string;
+            statusLineStaged: string;
+            statusLineDirty: string;
+            statusLineUntracked: string;
+            statusLineOutput: string;
+            statusLineCost: string;
+            statusLineSubagents: string;
+            pythonMode: string;
+        };
+        export: {
+            pageBg: string;
+            cardBg: string;
+            infoBg: string;
+        };
+        symbols: {
+            preset: string;
+            overrides: {
+                "icon.pi": string;
+                "status.running": string;
+                "md.bullet": string;
+            };
+        };
+    };
     "red-claw": {
         $schema: string;
         name: string;

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

@@ -302,6 +302,7 @@ export interface InteractiveModeContext {
     showPetSelector(): void;
     showHistorySearch(): Promise<void>;
     showExtensionsDashboard(): void;
+    showCustomizationDashboard(): void;
     showAgentsDashboard(): void;
     showModelSelector(options?: {
         temporaryOnly?: boolean;

package/dist/types/modes/utils/injected-user-submission.d.ts

@@ -6,6 +6,16 @@ import type { InteractiveModeContext } from "../types";
  * `AgentSession.sendUserMessage` (text parts joined with "\n") so the resulting
  * text matches the eventual user `message_start` payload.
  */
+/**
+ * Validate extension `sendUserMessage` content at the owning interactive
+ * boundary, before session delivery and UI bookkeeping. Returns a typed
+ * `invalid_input` Error when the content container or any array element is
+ * absent/null/malformed — exactly the shapes that would make
+ * `normalizeInjectedUserContent`'s `for-of` dereference (`part.type`) throw an
+ * untyped TypeError synchronously before the caller's `send.catch` is attached
+ * (unhandled rejection → resident crash).
+ */
+export declare function extensionUserMessageContentError(content: string | (TextContent | ImageContent)[]): Error | undefined;
 export declare function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {
     text: string;
     images: ImageContent[];