@gajae-code/coding-agent 0.10.2 → 0.11.1

package/dist/types/main.d.ts

@@ -9,20 +9,20 @@ import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import type { AcpStartupOptions } from "./modes/acp/startup-options";
 import type { SessionSelectionResult } from "./modes/components/session-selector";
 import type { InteractiveMode } from "./modes/interactive-mode";
 import type { PrintModeOptions } from "./modes/print-mode";
 import { initTheme } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import type { MCPManager } from "./runtime-mcp";
-import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
+import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
-import type { AuthStorage } from "./session/auth-storage";
 import { type ResumeSessionIdentity, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
 import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
 import type { LspStartupServerInfo } from "./tools";
 import type { EventBus } from "./utils/event-bus";
-export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "rpc" | "rpc-ui" | "acp" | "bridge";
+export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "acp";
 export declare function classifyStartupUpdateRoute(parsed: Pick<Args, "print" | "mode">, autoPrint: boolean): StartupUpdateRoute;
 /** Coordinates the non-blocking update check around the interactive UI lifecycle. */
 export declare class StartupUpdateOrchestrator {
@@ -36,46 +36,44 @@ export interface StartupUpdateInteractiveMode {
     showNewVersionNotification: (version: string) => void;
 }
 export declare function initializeInteractiveModeWithStartupUpdate(mode: StartupUpdateInteractiveMode, startupUpdate: StartupUpdateOrchestrator): Promise<void>;
+/**
+ * Translate only ACP startup settings with a canonical SDK control carrier.
+ * Every other local-session flag is rejected so the broker-backed ACP host
+ * never appears to accept options it cannot apply to its remote session.
+ */
+export declare function resolveAcpStartupOptions(parsed: Pick<Args, "allowHome" | "apiKey" | "appendSystemPrompt" | "credential" | "continue" | "default" | "cwd" | "fileArgs" | "fork" | "hooks" | "messages" | "mpreset" | "mcpConfig" | "model" | "models" | "noLsp" | "noPty" | "noRules" | "noSession" | "noSkills" | "noTitle" | "noTools" | "pluginDirs" | "print" | "provider" | "providerSessionId" | "resume" | "sessionDir" | "skills" | "slow" | "smol" | "plan" | "systemPrompt" | "thinking" | "tmux" | "tools" | "extensions" | "unknownFlags">, sessionOptions: Pick<CreateAgentSessionOptions, "model" | "modelPattern" | "thinkingLevel">): AcpStartupOptions;
 declare function readPipedInput(): Promise<string | undefined>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
 }
 export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
-type CreateSessionForMain = (options: CreateAgentSessionOptions, context?: {
-    skipPostCreateModelRefresh?: boolean;
-}) => Promise<CreateAgentSessionResult>;
-type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-export interface AcpSessionFactoryOptions {
-    baseOptions: CreateAgentSessionOptions;
-    settings: Settings;
-    sessionDir?: string;
-    authStorage: AuthStorage;
-    modelRegistry: ModelRegistry;
-    parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
-    rawArgs: string[];
-    createSession: CreateSessionForMain;
-}
-export declare function applyStartupModelProfiles(args: {
+type StartupModelProfileArgs = {
     session: AgentSession;
     settings: Settings;
     modelRegistry: ModelRegistry;
     parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
     startupModel?: CreateAgentSessionOptions["model"];
     startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
-}): Promise<void>;
-export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof applyStartupModelProfiles>[0]): Promise<void>;
-/**
- * Build the per-`session/new` factory used by ACP mode.
- *
- * MCP servers in ACP sessions are owned exclusively by the ACP client, which
- * supplies them through `session/new.mcpServers` and re-applies them via
- * {@link AcpAgent#configureMcpServers}. We therefore force `enableMCP: false`
- * on every session created here so {@link createAgentSession} skips the on-disk
- * `.mcp.json` discovery path — otherwise host MCP tools land in the session's
- * tool registry and shadow the client-supplied servers (issue #1234).
- */
-export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+};
+export declare function applyStartupModelProfiles(args: StartupModelProfileArgs): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: StartupModelProfileArgs): Promise<void>;
+export declare function isStartupModelProfileCredentialRecoveryEligible(options: {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): boolean;
+export declare function applyStartupModelProfilesForRoot(args: StartupModelProfileArgs & {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): Promise<{
+    recoverableErrors: string[];
+}>;
 interface InteractiveModeFactoryOptions {
     session: AgentSession;
     version: string;
@@ -105,15 +103,13 @@ export interface RlmPreset {
     applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
     onSessionCreated?: (session: AgentSession) => void | Promise<void>;
 }
-type RunRpcMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"], options?: {
-    listen?: string;
-}) => Promise<void>;
-type RunBridgeMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"]) => Promise<void>;
 type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
 export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
-    runAcpMode?: (createSession: AcpSessionFactory) => Promise<void>;
+    runAcpMode?: (options?: {
+        agentDir?: string;
+    }) => Promise<void>;
     settings?: Settings;
     rlmPreset?: RlmPreset;
     suppressProcessExit?: boolean;
@@ -124,8 +120,6 @@ export interface RunRootCommandDependencies {
     readPipedInput?: typeof readPipedInput;
     runStartupCredentialAutoImportIfNeeded?: typeof runStartupCredentialAutoImportIfNeeded;
     getChangelogForDisplay?: typeof getChangelogForDisplay;
-    runRpcMode?: RunRpcMode;
-    runBridgeMode?: RunBridgeMode;
     createInteractiveMode?: CreateInteractiveMode;
     runPrintMode?: RunPrintMode;
     isResumePickerTerminal?: ResumePickerTerminalCheck;

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

@@ -1,56 +1,239 @@
 import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, 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 { ExtensionUIContext } from "../../extensibility/extensions";
-import type { AgentSession } from "../../session/agent-session";
+import { type AcpProviderRegistration, AcpSdkAdapter } from "../../sdk/acp";
+import type { AcpStartupOptions } from "./startup-options";
+export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+type JsonObject = Record<string, unknown>;
+/** Applies ACP's offset cursor after narrowing the broker listing to the requested cwd. */
+export declare function paginateAcpSessions(listed: unknown[], cwd: string | undefined, offset: number): ListSessionsResponse;
+export type TranscriptReplayBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
 /**
- * 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.
+ * The production transcript query exposes durable `{ body, textSummary }`
+ * entries, not an ACP-shaped `content` array. Historical session JSONL has no
+ * recoverable image bytes, so replay exposes that boundary rather than
+ * pretending images were restored.
  */
-export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
-type CreateAcpSession = (cwd: string) => Promise<AgentSession>;
+export interface TranscriptReplayContent {
+    blocks: TranscriptReplayBlock[];
+    images: {
+        available: false;
+        reason: "historical_transcript_images_unavailable";
+    };
+}
+export declare function transcriptReplayContent(entry: unknown): TranscriptReplayContent;
+/** Maps live canonical SDK config and model queries into the ACP 1.2.1 session state surface. */
+export declare function acpSessionStateFromConfig(query: unknown, modelsQuery?: unknown): {
+    configOptions: ({
+        id: string;
+        name: string;
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[];
+    } | {
+        id: "model";
+        name: "Model";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "thinking";
+        name: "Thinking";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "steeringMode";
+        name: "Steering queue";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "followUpMode";
+        name: "Follow-up queue";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "interruptMode";
+        name: "Interrupt mode";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    })[];
+    modes: {
+        availableModes: {
+            id: string;
+            name: string;
+        }[];
+        currentModeId: string;
+    };
+};
+/** Convert every ACP prompt block the agent advertises without silently discarding context. */
+export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
+    text: string;
+    images: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+};
+/** Registers a permission provider only when the ACP client requires prompts. */
+export declare function acpProviderRegistrations(capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpProviderRegistration[];
+/** Maps ACP permission handling to the session's canonical SDK policy. */
+export declare function applyAcpPermissionMode(adapter: Pick<AcpSdkAdapter, "control">, capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Applies CLI-provided ACP startup settings through SDK controls before session exposure. */
+export declare function applyAcpStartupOptions(adapter: Pick<AcpSdkAdapter, "setModel" | "control">, options: AcpStartupOptions | undefined): Promise<void>;
+/** ACP form elicitation uses the client-facing reverse surface without owning a session runtime. */
+export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, capabilities: ClientCapabilities | undefined): {
+    select: (message: string, options: string[], dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+    confirm: (message: string, detail?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<boolean>;
+    input: (message: string, placeholder?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+};
 /**
- * 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.
+ * ACP is a pure SDK client. Session processes are created and resumed by the
+ * broker, while all per-session operations use that session's authenticated SDK
+ * endpoint. This class deliberately imports neither AgentSession nor any local
+ * runtime host component.
  */
-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;
+    constructor(connection: AgentSideConnection, options?: {
+        agentDir?: string;
+        startupOptions?: AcpStartupOptions;
+    } | unknown);
     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>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
     closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
-    /**
-     * Hard delete an ACP session. `DeleteSessionRequest` carries only `sessionId`;
-     * the server owns authorization through the immutable canonical cwd scope and
-     * the complete strict scoped inventory snapshot.
-     *
-     * - No scope / unknown / already-deleted id → lookup-free `{}`.
-     * - Duplicate/conflict id → visible error; neither transcript nor artifacts change.
-     * - Active session → reserve `deleting`, drain/cancel prompt, flush, strict
-     *   dispose/close, recheck identity/state, then verified artifact-first deletion.
-     * - Concurrent delete callers join the terminal promise.
-     */
     deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
     setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
     setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
@@ -58,21 +241,9 @@ export declare class AcpAgent implements Agent {
     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>;
+    extMethod(method: string, params: JsonObject): Promise<JsonObject>;
+    extNotification(_method: string, _params: JsonObject): Promise<void>;
     get signal(): AbortSignal;
     get closed(): Promise<void>;
-    /**
-     * Connection-local shutdown promise. Resolves once all terminal work (dispose,
-     * active deletes, abort cleanup) has settled. `acp-mode.ts` awaits this after
-     * transport closure so `process.exit` never kills in-flight deletion/disposal.
-     */
-    get shutdownPromise(): Promise<void>;
 }
 export {};

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

@@ -6,4 +6,5 @@
  */
 import type { AgentSideConnection, ClientCapabilities } from "@agentclientprotocol/sdk";
 import type { ClientBridge } from "../../session/client-bridge";
+export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 export declare function createAcpClientBridge(connection: AgentSideConnection, sessionId: string, clientCapabilities: ClientCapabilities | undefined): ClientBridge;

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

@@ -1,17 +1,8 @@
 import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
-import type { AgentSession } from "../../session/agent-session";
-import { AcpAgent } from "./acp-agent";
-export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-export interface AcpConnectionHandle {
-    connection: AgentSideConnection;
-    agent: AcpAgent;
+import type { AcpStartupOptions } from "./startup-options";
+export interface AcpModeOptions {
+    agentDir?: string;
+    startupOptions?: AcpStartupOptions;
 }
-export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AgentSideConnection;
-/**
- * Create an ACP connection and return both the {@link AgentSideConnection} and the
- * underlying {@link AcpAgent}. Callers that need to await agent shutdown (terminal
- * delete/dispose work) after transport closure should use this instead of
- * {@link createAcpConnection}.
- */
-export declare function createAcpConnectionWithAgent(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AcpConnectionHandle;
-export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never>;
+export declare function createAcpConnection(transport: Stream, options?: AcpModeOptions): AgentSideConnection;
+export declare function runAcpMode(options?: AcpModeOptions): Promise<never>;

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

@@ -0,0 +1,4 @@
+import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+export declare function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpPermissionMode;

package/dist/types/modes/acp/startup-options.d.ts

@@ -0,0 +1,6 @@
+/** Startup settings that ACP can apply through the canonical SDK control surface. */
+export interface AcpStartupOptions {
+    modelId?: string;
+    modelPreset?: string;
+    thinkingLevel?: string;
+}

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

@@ -1,11 +1,14 @@
 import { Container } from "@gajae-code/tui";
 import type { ModelRegistry } from "../../config/model-registry";
+import { type ModelSelectorValue } from "../../config/model-selector-value";
 import { Settings } from "../../config/settings";
 interface AgentDashboardModelContext {
     modelRegistry?: ModelRegistry;
     activeModelPattern?: string;
     defaultModelPattern?: string;
 }
+export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined): import("@gajae-code/ai").Model<import("@gajae-code/ai").Api>;
+export declare function updateAgentModelOverride(overrides: Record<string, ModelSelectorValue>, agentName: string, rawValue: string): Record<string, ModelSelectorValue>;
 export declare class AgentDashboard extends Container {
     #private;
     private readonly cwd;

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

@@ -47,6 +47,7 @@ export declare class ModelSelectorComponent extends Container {
         isCurrentModelFastModeActive?: () => boolean;
         currentThinkingLevel?: ThinkingLevel;
         activeModelProfile?: string;
+        configuredDefaultChain?: readonly string[];
     });
     refreshRoleAssignments(options?: {
         currentModel?: Model;

package/dist/types/modes/components/notifications-settings-editor.d.ts

@@ -0,0 +1,135 @@
+import { type Component, type Focusable, type SecretValue } from "@gajae-code/tui";
+import type { CasReceipt } from "../../config/atomic-yaml-patch";
+import type { BlockedTelegramRestoreResult, ProposedTelegramIdentity, TelegramDaemonReconnectOutcome } from "../../sdk/bus/notification-orchestration";
+import type { NotificationHealthReport, NotificationRecoveryReport, NotificationStatusReport, NotificationTestResult } from "../../sdk/bus/notification-service";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../../sdk/bus/session-control";
+/** Safe scalar notification preferences. Credentials and destination IDs are deliberately absent. */
+export interface NotificationsEditorPreferences {
+    redact: boolean;
+    verbosity: "lean" | "verbose";
+    sessionScope: "all" | "primary";
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+/** Secret-safe snapshot used to render the Notifications tab. */
+export interface NotificationsEditorState {
+    status: NotificationStatusReport;
+    session: NotificationSessionStatus;
+    preferences: NotificationsEditorPreferences;
+    health?: NotificationHealthReport;
+}
+/**
+ * A one-way setup value accepted from the masked input. The operation adapter
+ * consumes the secret and returns a safe-to-render prepared draft.
+ */
+export interface NotificationsEditorSetupInput {
+    token: SecretValue;
+    /** Optional: omit to use daemon-aware private-chat discovery when polling is safe. */
+    chatId?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+/**
+ * Secret-safe setup draft. The adapter may retain its private credential while
+ * this object is live, but no raw token is exposed through this contract.
+ */
+export interface PreparedTelegramConfiguration {
+    chatId: string;
+    tokenMask: string;
+    tokenFingerprint?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+export interface NotificationsPreflightResult {
+    status: "ready" | "aborted" | "cancelled" | "error";
+    identity: ProposedTelegramIdentity;
+    message: string;
+    pairingSource?: "discovered" | "provided" | "reused";
+    draft?: PreparedTelegramConfiguration;
+}
+/** A successful configuration save always carries an opaque CAS receipt. */
+export type NotificationsConfigureCommitResult = {
+    status: "saved";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "blocked_identity";
+    receipt: CasReceipt;
+    message: string;
+    restore(): Promise<BlockedTelegramRestoreResult>;
+    retainCommitted(): void;
+};
+export interface NotificationsMutationResult {
+    message: string;
+    receipt?: CasReceipt;
+}
+export type NotificationsSaveInactiveResult = {
+    status: "saved_inactive";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "unavailable";
+    guidance: string;
+};
+/**
+ * Controller-injected boundary for the direct Notifications editor.
+ *
+ * The component only renders this contract and sends user intent through it:
+ * it never reads Settings, starts a daemon, or calls notification services.
+ */
+export interface NotificationsEditorOperations {
+    /** Combines a buildNotificationStatusReport-shaped status snapshot with the current session-control query. */
+    loadState(): Promise<NotificationsEditorState>;
+    /** Performs offline health refreshes and a non-cancellable reachability probe when requested. */
+    refreshHealth(input: {
+        probe: boolean;
+        signal?: AbortSignal;
+    }): Promise<NotificationHealthReport>;
+    sendTest(): Promise<NotificationTestResult>;
+    recover(): Promise<NotificationRecoveryReport>;
+    reconnect(): Promise<TelegramDaemonReconnectOutcome>;
+    /** Validates/discovers a Telegram destination and returns a secret-safe prepared draft. */
+    preflightProposedIdentity(input: NotificationsEditorSetupInput, signal: AbortSignal): Promise<NotificationsPreflightResult>;
+    /** Atomically persists a prepared Telegram configuration and returns its CAS-backed receipt. */
+    commitConfigure(draft: PreparedTelegramConfiguration): Promise<NotificationsConfigureCommitResult>;
+    /** Stores a prepared Telegram configuration inactive when the mixed-adapter rule permits it. */
+    saveInactive(draft: PreparedTelegramConfiguration): Promise<NotificationsSaveInactiveResult>;
+    /** Clears adapter-local ephemeral credential material for a prepared setup draft. Idempotent. */
+    discardConfigureDraft(draft: PreparedTelegramConfiguration): void;
+    /** Enables globally without requesting or exposing a credential. */
+    enableGlobally(): Promise<NotificationsMutationResult>;
+    disableGlobally(): Promise<NotificationsMutationResult>;
+    /** Removes only Telegram configuration; the adapter preserves Discord/Slack when configured. */
+    removeTelegram(): Promise<NotificationsMutationResult & {
+        globallyDisabled?: boolean;
+    }>;
+    setSessionLocal(enabled: boolean): Promise<NotificationSessionReconcileResult>;
+    /** Atomically persists the scalar preference draft. */
+    commitPreferences(preferences: NotificationsEditorPreferences): Promise<NotificationsMutationResult>;
+    /** Reconciles the current session after durable global configuration changes. */
+    reconcileCurrentSession(): Promise<NotificationSessionReconcileResult>;
+}
+export interface NotificationsSettingsEditorCallbacks {
+    onCancel?: () => void;
+}
+type EditorMode = "home" | "provider-selection" | "chat-entry" | "token-entry" | "pairing" | "review" | "preferences" | "confirmation";
+/**
+ * Direct tab content for notification setup and operations. It is deliberately
+ * independent of Settings and notification services; WI7b injects the adapter.
+ */
+export declare class NotificationsSettingsEditorComponent implements Component, Focusable {
+    #private;
+    private readonly operations;
+    private readonly callbacks;
+    focused: boolean;
+    constructor(operations: NotificationsEditorOperations, callbacks?: NotificationsSettingsEditorCallbacks);
+    /** True while a guarded operation or blocked restore/retain decision owns the editor. */
+    get navigationLocked(): boolean;
+    /** Current state is exposed for selector lifecycle coordination and focused tests. */
+    get mode(): EditorMode;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+}
+export {};