@gajae-code/coding-agent 0.13.3 → 0.14.0

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/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 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;
-        forcePixelProtocol?: "sixel" | "kitty" | "iterm2";
-        /** Random [min, max] ms between auto-flexes; null disables. */
+        syncManagedItermCursor: (row: number, column: number) => Promise<boolean>;
+        forcePixelProtocol?: "sixel" | "kitty";
         autoFlexGapMs?: [number, number] | null;
     });
-    /** Protocol available for the real-pixel pet, if any. */
-    static pixelProtocol(): "sixel" | "kitty" | "iterm2" | null;
+    static pixelProtocol(): "sixel" | "kitty" | "iterm" | null;
     get mode(): PetMode;
     get isFlexing(): boolean;
-    setMode(mode: string): 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. */
+    setMode(mode: PetMode): void;
+    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" | "iterm2";
-export declare const PET_UNAVAILABLE_DESCRIPTION = "Unavailable: requires compatible Kitty, iTerm2, or Sixel overlay rendering";
-export declare const PET_SAVED_UNAVAILABLE_DESCRIPTION = "Saved, unavailable \u2014 requires compatible Kitty, iTerm2, 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, iTerm2, or a terminal with compatible Sixel support.";
+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 getPetPixelProtocol(env?: NodeJS.ProcessEnv): PetPixelProtocol | null;
+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/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/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[];

package/dist/types/runtime-mcp/config.d.ts

@@ -15,6 +15,13 @@ export interface LoadMCPConfigsOptions {
     filterBrowser?: boolean;
     /** Only include startup-eligible servers; exact-config sessions always enforce autoload !== false. */
     autoloadOnly?: boolean;
+    /**
+     * Restrict discovery to GJC's own native config (`.gjc/` project and
+     * `~/.gjc/agent/` user scopes). Conventional standalone sessions use this
+     * mode: Claude Code/Codex project/global MCP files are explicit import
+     * sources into `.gjc`, not implicit competing runtime authorities.
+     */
+    nativeOnly?: boolean;
     /** Load only this explicit MCP config file. */
     configPath?: string;
 }
@@ -28,6 +35,8 @@ export interface LoadMCPConfigsResult {
     sources: Record<string, SourceMeta>;
     /** Whether the explicit configuration was unavailable or contained invalid entries. */
     configurationWarning: boolean;
+    /** Provider warnings surfaced during discovery (parse/skip diagnostics). */
+    warnings: string[];
 }
 /**
  * Load all MCP server configs from standard locations.

package/dist/types/runtime-mcp/manager.d.ts

@@ -9,9 +9,10 @@ import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";
 import { MCPConnectionPool, type MCPPoolLease } from "./pool";
+import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
-import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
+import type { MCPGetPromptResult, MCPInputRequestHandler, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
 export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
 export declare function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number;
 export declare class MCPManagerLifecycleError extends Error {
@@ -54,6 +55,12 @@ export interface MCPDiscoverOptions {
     filterBrowser?: boolean;
     /** Only connect servers with autoload !== false (default: false) */
     autoloadOnly?: boolean;
+    /**
+     * Restrict discovery to GJC's native `.gjc` scopes (user + project).
+     * Runtime MCP authority for GJC sessions; Claude Code/Codex files are
+     * explicit import sources into `.gjc`, not implicit runtime authorities.
+     */
+    nativeOnly?: boolean;
     /** Called when starting to connect to servers */
     onConnecting?: (serverNames: string[]) => void;
     /** Load only this explicit MCP config file. */
@@ -125,6 +132,13 @@ export declare class MCPManager {
      * Set the auth storage for resolving OAuth credentials.
      */
     setAuthStorage(authStorage: AuthStorage): void;
+    /**
+     * Register the handler for modern MRTR `input_required` results (structured
+     * elicitation/roots/sampling input requests). Runtimes with an interactive
+     * question surface (e.g. ACP `elicitation/create`) register here; without a
+     * handler, `input_required` fails explicitly instead of hanging.
+     */
+    setInputRequestHandler(handler: MCPInputRequestHandler | null): void;
     /**
      * Discover and connect to all MCP servers from .mcp.json files.
      * Returns tools and any connection errors.
@@ -147,6 +161,17 @@ export declare class MCPManager {
      * Get current connection status for a server.
      */
     getConnectionStatus(name: string): "connected" | "connecting" | "disconnected";
+    /**
+     * Get the authoritative protocol observation for a connected server
+     * (preference, negotiated era/version, downgrade decision, deprecation state).
+     * Secret-free; the single observation model consumed by customization doctor
+     * (#4288) and /extensions (#4291). Returns undefined when not connected.
+     */
+    getProtocolObservation(name: string): MCPProtocolObservation | undefined;
+    /**
+     * Snapshot of protocol observations for all connected servers.
+     */
+    getProtocolObservations(): ReadonlyMap<string, MCPProtocolObservation>;
     /**
      * Get the source metadata for a server.
      */

package/dist/types/runtime-mcp/oauth-discovery.d.ts

@@ -10,6 +10,10 @@ export interface OAuthEndpoints {
     tokenUrl: string;
     clientId?: string;
     scopes?: string;
+    /** Issuer recorded from the validated metadata document (RFC 9207). */
+    issuer?: string;
+    /** `authorization_response_iss_parameter_supported` from the same metadata. */
+    authorizationResponseIssSupported?: boolean;
 }
 export interface AuthDetectionResult {
     requiresAuth: boolean;

package/dist/types/runtime-mcp/oauth-flow.d.ts

@@ -6,12 +6,22 @@
  */
 import { OAuthCallbackFlow } from "@gajae-code/ai/utils/oauth/callback-server";
 import type { OAuthController, OAuthCredentials } from "@gajae-code/ai/utils/oauth/types";
+/**
+ * Canonical MCP server resource URI per RFC 8707 §2: absolute URI, lowercase
+ * scheme/host, no fragment, no trailing slash on an empty path.
+ */
+export declare function canonicalMCPResourceUri(raw: string): string | undefined;
 export interface MCPOAuthConfig {
     /** Authorization endpoint URL */
     authorizationUrl: string;
     /** Token endpoint URL */
     tokenUrl: string;
-    /** Client ID (optional when already embedded in authorization URL) */
+    /**
+     * Client ID (optional when already embedded in authorization URL). An
+     * HTTPS URL here is a Client ID Metadata Document (CIMD) reference per
+     * MCP 2026-07-28 and is used as-is; Dynamic Client Registration is only a
+     * deprecated backwards-compatibility fallback when no client id exists.
+     */
     clientId?: string;
     /** Client secret (optional for PKCE flows) */
     clientSecret?: string;
@@ -23,6 +33,19 @@ export interface MCPOAuthConfig {
     callbackPort?: number;
     /** Custom callback path (default: /callback or redirectUri pathname) */
     callbackPath?: string;
+    /**
+     * Canonical URI of the target MCP server (RFC 8707). Sent as the `resource`
+     * parameter on BOTH the authorization and token requests, regardless of
+     * authorization-server support.
+     */
+    resource?: string;
+    /**
+     * Expected authorization-server issuer recorded from validated discovery
+     * metadata (RFC 9207 / MCP 2026-07-28). Validation fails closed on mismatch.
+     */
+    issuer?: string;
+    /** `authorization_response_iss_parameter_supported` from the same metadata. */
+    issuerResponseIssSupported?: boolean;
 }
 /**
  * Generic OAuth flow for MCP servers.

package/dist/types/runtime-mcp/pool-key.d.ts

@@ -48,6 +48,8 @@ export interface MCPPoolKeyIdentity {
     authScopeId: string;
     pluginNetworkPolicyId: string;
     capabilityProfile: MCPPoolCapabilityProfile;
+    /** Resolved protocol preference (auto | 2026-07-28 | legacy); partitions protocol generations. */
+    protocolPreference: string;
     sessionId?: string;
 }
 /**