@gajae-code/coding-agent 0.12.6 → 0.12.8

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -21,9 +21,16 @@ export type ChatDaemonAction = "stop" | "reload";
  * daemon transports. Generation 16 applies Telegram sound-policy configuration
  * through shared notification parsing. Generation 17 bound managed-session
  * replacement to exact native filesystem authority; generation 18 retired that
- * binding, generation 19 bound exact cleanup to parent/link-count authority,
- * generation 20 refreshed retained cleanup semantics, and generation 21 hardens
- * exact Bash process-tree ownership shared by chat daemon cleanup.
+ * binding, and generation 19 binds exact cleanup to parent/link-count authority
+ * while also adding durable provider-intent admission without changing lifecycle
+ * behavior. Generation 20 discovers isolated chat-only session endpoints when
+ * Telegram identity ownership is blocked. Discord generation 21 applies rustfmt
+ * and clippy-equivalent cleanup to the pi-shell process-tree authority (#3682).
+ * Discord generation 22 / slack generation 21 refreshes retained cleanup
+ * semantics; discord generation 23 / slack generation 22 hardens exact Bash
+ * process-tree ownership shared by chat daemon cleanup.
+ * Discord generation 24 / slack generation 23 apply provider-completeness and
+ * effective-enable admission to chat daemon lifecycle controls.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;
@@ -104,6 +111,7 @@ export declare class ChatDaemonController implements BuiltInDaemonController {
     readonly kind: ChatDaemonKind;
     constructor(settings: Settings, kind: ChatDaemonKind, deps?: ChatDaemonControlDeps);
     private identity;
+    private effectivelyEnabled;
     private alive;
     status(): Promise<DaemonStatus>;
     stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;

package/dist/types/sdk/bus/config.d.ts

@@ -22,9 +22,29 @@ export interface TelegramActivationMarker {
 export type TelegramActivationMarkers = Record<string, TelegramActivationMarker>;
 /** Validate and clone activation markers crossing the settings boundary. */
 export declare function readTelegramActivationMarkers(value?: unknown): TelegramActivationMarkers;
+export type NotificationProvider = "telegram" | "discord" | "slack";
+export type NotificationRuntime = "inactive" | "starting" | "ready" | "attached" | "blocked" | "failed";
+export type ProviderSecretDisposition = "keep" | "replace" | "remove";
+export type ProviderResolutionIssueCode = "missing" | "blank" | "wrong_type" | "invalid_container" | "contradictory";
+export interface ProviderResolutionIssue {
+    path: string;
+    code: ProviderResolutionIssueCode;
+}
+export type NotificationProviderIssueCode = ProviderResolutionIssueCode;
+export type NotificationProviderIssue = ProviderResolutionIssue;
+export interface ProviderResolution {
+    provider: NotificationProvider;
+    configured: boolean;
+    quarantined: boolean;
+    desiredEnabled: boolean;
+    desiredSource: "explicit" | "legacy";
+    effectiveEnabled: boolean;
+    issues: readonly ProviderResolutionIssue[];
+}
 export interface NotificationSettingsSnapshot {
     enabled: boolean;
     telegram: {
+        enabled?: boolean;
         botToken?: string;
         chatId?: string;
         activation?: Record<string, unknown>;
@@ -49,12 +69,14 @@ export interface NotificationSettingsSnapshot {
         };
     };
     discord: {
+        enabled?: boolean;
         botToken?: string;
         applicationId?: string;
         guildId?: string;
         parentChannelId?: string;
     };
     slack: {
+        enabled?: boolean;
         botToken?: string;
         appToken?: string;
         workspaceId?: string;
@@ -65,33 +87,38 @@ export interface NotificationSettingsSnapshot {
     verbosity: "lean" | "verbose";
     sessionScope: "all" | "primary";
     idleTimeoutMs: number;
+    /** Safe provider-local validation issues. Raw values never cross this boundary. */
+    providerIssues?: Partial<Record<NotificationProvider, readonly ProviderResolutionIssue[]>>;
 }
 /**
  * Narrow settings boundary for remote notification identity and behavior.
- * Implementations must return only user-global values, with schema defaults
- * applied; project settings and runtime overrides are intentionally excluded.
+ * Implementations return only user-global values; project settings and runtime
+ * overrides are intentionally excluded.
  */
 export interface NotificationSettingsReader {
     getNotificationSettingsSnapshot(): NotificationSettingsSnapshot;
     getAgentDir(): string;
 }
-/**
- * Validate and snapshot the raw global notification configuration used by both
- * the interactive host and the lightweight daemon process.
- */
+/** Validate and snapshot raw global notification configuration without leaking invalid provider values. */
 export declare function parseNotificationSettingsSnapshot(rawConfig?: unknown): NotificationSettingsSnapshot;
 export interface NotificationConfig {
     enabled: boolean;
     botToken?: string;
     activation?: TelegramActivationMarkers;
     chatId?: string;
+    /** Optional nested Telegram intent metadata; absent means legacy configuration. */
+    telegram?: {
+        enabled?: boolean;
+    };
     discord: {
+        enabled?: boolean;
         botToken?: string;
         applicationId?: string;
         guildId?: string;
         parentChannelId?: string;
     };
     slack: {
+        enabled?: boolean;
         botToken?: string;
         appToken?: string;
         workspaceId?: string;
@@ -100,11 +127,6 @@ export interface NotificationConfig {
     };
     redact: boolean;
     verbosity: "lean" | "verbose";
-    /**
-     * Which sessions may register a notification endpoint. `all` (default)
-     * preserves historical behavior; `primary` suppresses GJC-spawned children
-     * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
-     */
     sessionScope: "all" | "primary";
     sound: "all" | "important" | "none";
     idleTimeoutMs: number;
@@ -124,62 +146,24 @@ export interface NotificationConfig {
         enabled: boolean;
     };
     topics: {
-        /**
-         * Optional Telegram forum-topic name template with `{repo}`, `{branch}`,
-         * and `{title}` placeholders. Unset preserves the built-in
-         * `{repo}/{branch} - {title}` composition (with its title/repo/branch
-         * fallbacks).
-         */
         nameTemplate?: string;
     };
+    providerIssues?: Partial<Record<NotificationProvider, readonly ProviderResolutionIssue[]>>;
 }
 /** Read typed global-only notification config from a narrow settings reader. */
 export declare function getNotificationConfig(settings: NotificationSettingsReader): NotificationConfig;
-declare const notificationConfigSchema: z.ZodObject<{
-    notifications: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        discord: z.ZodOptional<z.ZodObject<{
-            botToken: z.ZodOptional<z.ZodString>;
-            applicationId: z.ZodOptional<z.ZodString>;
-            guildId: z.ZodOptional<z.ZodString>;
-            parentChannelId: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>;
-        slack: z.ZodOptional<z.ZodObject<{
-            botToken: z.ZodOptional<z.ZodString>;
-            appToken: z.ZodOptional<z.ZodString>;
-            workspaceId: z.ZodOptional<z.ZodString>;
-            channelId: z.ZodOptional<z.ZodString>;
-            authorizedUserId: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>;
-        redact: z.ZodOptional<z.ZodBoolean>;
-        verbosity: z.ZodOptional<z.ZodEnum<{
-            lean: "lean";
-            verbose: "verbose";
-        }>>;
-    }, z.core.$loose>>;
-}, z.core.$loose>;
+declare const notificationConfigSchema: z.ZodObject<{}, z.core.$loose>;
 type NotificationConfigFile = z.infer<typeof notificationConfigSchema>;
 /** Read daemon settings through the canonical validated config-file boundary. */
 export declare function loadNotificationConfigFile(agentDir: string): LoadResult<NotificationConfigFile>;
-export declare function notificationConfigFromFile(value: NotificationConfigFile): Pick<NotificationConfig, "enabled" | "discord" | "slack" | "redact" | "verbosity">;
+export declare function notificationConfigFromFile(value: NotificationConfigFile): NotificationConfig;
 export declare function hasNonBlankValue(value: string | undefined): boolean;
-/**
- * Resolve live assistant streaming independently of generic notification
- * lifecycle enablement. Explicit environment values override the durable
- * Telegram preference; otherwise streaming is available only to an active
- * configured Telegram identity.
- */
-export declare function isNotificationStreamingEnabled(input: {
-    cfg: NotificationConfig;
-    env: NodeJS.ProcessEnv;
-}): boolean;
-/** Is Telegram configured with usable non-blank boundary credentials? */
-export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export declare function isProviderComplete(cfg: NotificationConfig, provider: NotificationProvider): boolean;
+export declare function isTelegramComplete(cfg: NotificationConfig): cfg is NotificationConfig & {
     botToken: string;
     chatId: string;
 };
-/** Is Discord configured with all credentials and routing identifiers required by its daemon. */
-export declare function isDiscordConfigured(cfg: Pick<NotificationConfig, "enabled" | "discord">): cfg is Pick<NotificationConfig, "enabled"> & {
+export declare function isDiscordComplete(cfg: NotificationConfig): cfg is NotificationConfig & {
     discord: {
         botToken: string;
         applicationId: string;
@@ -187,8 +171,7 @@ export declare function isDiscordConfigured(cfg: Pick<NotificationConfig, "enabl
         parentChannelId: string;
     };
 };
-/** Is Slack configured with both SDK tokens and its workspace/channel routing identifiers. */
-export declare function isSlackConfigured(cfg: Pick<NotificationConfig, "enabled" | "slack">): cfg is Pick<NotificationConfig, "enabled"> & {
+export declare function isSlackComplete(cfg: NotificationConfig): cfg is NotificationConfig & {
     slack: {
         botToken: string;
         appToken: string;
@@ -196,80 +179,59 @@ export declare function isSlackConfigured(cfg: Pick<NotificationConfig, "enabled
         channelId: string;
     };
 };
-/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
-export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
+export declare function resolveNotificationProvider(cfg: NotificationConfig, provider: NotificationProvider): ProviderResolution;
+export declare function isProviderEffectivelyEnabled(cfg: NotificationConfig, provider: NotificationProvider): boolean;
+export declare function hasAnyCompleteProvider(cfg: NotificationConfig): boolean;
+export declare function hasAnyEffectivelyEnabledProvider(cfg: NotificationConfig): boolean;
 /**
- * Per-run opt-out for completion notifications, honored before settings lookups.
- *
- * `GJC_NOTIFY=off` (also `0` / `false`, case-insensitive) suppresses the
- * completion notification surface for this process only. `config.yml` is
- * untouched and child processes inherit the env var, which lets non-interactive
- * fleet runs (`gjc -p --no-session`) stay silent even when a user-level/global
- * completion notification configuration is enabled.
+ * Resolve generic live-stream policy. This policy only governs automatic
+ * current-session frames; it never changes durable provider eligibility.
  */
+export type GenericNotificationSessionSource = "hard_opt_out" | "session_local_off" | "explicit_env" | "token_env" | "configured_provider" | "session_scope" | "none";
+export interface GenericNotificationSessionEligibility {
+    enabled: boolean;
+    source: GenericNotificationSessionSource;
+}
+export type GenericNotificationStreamSource = "session_not_admitted" | "env_on" | "env_off" | "durable_telegram" | "none";
+export interface GenericNotificationStreamPolicy {
+    enabled: boolean;
+    source: GenericNotificationStreamSource;
+}
+export interface GenericNotificationSessionEligibilityInput {
+    cfg: NotificationConfig;
+    env: NodeJS.ProcessEnv;
+    sessionDisabled: boolean;
+    spawnedByGjc?: boolean;
+}
+export declare function resolveGenericNotificationSessionEligibility(input: GenericNotificationSessionEligibilityInput): GenericNotificationSessionEligibility;
+export declare function resolveGenericNotificationStreamPolicy(input: {
+    cfg: NotificationConfig;
+    env: NodeJS.ProcessEnv;
+    genericSessionEnabled: boolean;
+}): GenericNotificationStreamPolicy;
 export declare function completionNotifyDisabledByEnv(env: NodeJS.ProcessEnv): boolean;
-/** Canonical host eligibility for the dormant notification session surface. */
 export interface NotificationHostEligibilityInput {
     env: NodeJS.ProcessEnv;
-    /** False for host modes that cannot own a notification session endpoint. */
     hostModeSupported?: boolean;
-    /** Task recursion depth; helper/subagent sessions must not own remote surfaces. */
     taskDepth?: number;
-    /** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
     parentTaskPrefix?: string;
-    /** Role-agent type/name; present for task sessions even if depth metadata is lost. */
     currentAgentType?: string;
-    /** Canonical global session scope; absent preserves the default `all` behavior. */
     sessionScope?: NotificationConfig["sessionScope"];
-    /** Whether this process was spawned by one of GJC's marked child spawn sites. */
     spawnedByGjc?: boolean;
 }
-/**
- * Resolve whether this host may receive the dormant notification controller.
- * This intentionally says nothing about whether an adapter is configured: an
- * eligible unconfigured host still gets a zero-side-effect control surface.
- */
-export declare function isNotificationHostEligible(input: NotificationHostEligibilityInput): boolean;
-/**
- * Legacy compatibility helper for callers that require both host eligibility
- * and a currently configured or explicit notification runtime.
- */
-export declare function shouldRegisterNotificationsExtension(input: {
+/** Generic host eligibility for the dormant automatic notification surface. */
+export declare function isGenericNotificationHostEligible(input: NotificationHostEligibilityInput): boolean;
+export interface GenericNotificationRegistrationInput {
     env: NodeJS.ProcessEnv;
     cfg?: NotificationConfig;
-    /** Task recursion depth; helper/subagent sessions must not spawn remote surfaces. */
     taskDepth?: number;
-    /** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
     parentTaskPrefix?: string;
-    /** Role-agent type/name; present for task sessions even if depth metadata is lost. */
     currentAgentType?: string;
-    /**
-     * True when this session was launched by one of GJC's own programmatic
-     * separate-process child spawn sites (marked via {@link SPAWN_PROVENANCE_ENV}).
-     * Under `notifications.sessionScope = "primary"` such children are suppressed
-     * unless they explicitly opt in, so an interactive parent that fans out work
-     * does not flood the paired chat with topics for children the user never
-     * asked for. User-opened sessions (CLI/tmux/headless) never carry the marker.
-     */
-    spawnedByGjc?: boolean;
-}): boolean;
-/**
- * Resolve whether THIS session should run notifications.
- * Precedence (highest first):
- *  1) env.GJC_NOTIFICATIONS === "0"  -> false (hard opt-out)
- *  2) sessionDisabled === true       -> false (local /notify off)
- *  3) env.GJC_NOTIFICATIONS === "1" || env.GJC_NOTIFICATIONS_TOKEN present -> true (legacy explicit)
- *  4) spawned GJC child with `sessionScope=primary` -> false
- *  5) isGloballyConfigured(cfg)      -> true (global auto-on)
- *  6) otherwise false
- */
-export declare function isSessionNotificationsEnabled(input: {
-    cfg: NotificationConfig;
-    env: NodeJS.ProcessEnv;
-    sessionDisabled: boolean;
-    /** This process was programmatically spawned by GJC (consumed at SDK startup). */
     spawnedByGjc?: boolean;
-}): boolean;
+}
+/** Generic registration admission; direct provider actions do not call this helper. */
+export declare function shouldRegisterGenericNotificationsExtension(input: GenericNotificationRegistrationInput): boolean;
+export declare function isGenericNotificationSessionEnabled(input: GenericNotificationSessionEligibilityInput): boolean;
 /** Mask a bot token for display: first 4 chars + "…" + "(len N)"; "(unset)" when undefined/empty. Never reveal full token. */
 export declare function maskToken(token: string | undefined): string;
 /** Stable non-reversible fingerprint of a token: sha256 hex, first 12 chars. */

package/dist/types/sdk/bus/discord-live-provider.d.ts

@@ -1,4 +1,4 @@
-import type { DiscordInboundEvent, DiscordMessageComponent, DiscordProvider, DiscordThread } from "./discord-provider";
+import type { DiscordConfigurationProbeResult, DiscordDiagnosticProvider, DiscordInboundEvent, DiscordMessageComponent, DiscordOneShotTestResult, DiscordProvider, DiscordThread } from "./discord-provider";
 export interface DiscordGatewaySocket {
     readonly readyState: number;
     send(data: string): void;
@@ -21,7 +21,7 @@ export interface DiscordLiveProviderOptions {
     apiBaseUrl?: string;
 }
 /** Discord REST/Gateway implementation. The only credential is held privately and is never emitted. */
-export declare class DiscordLiveProvider implements DiscordProvider {
+export declare class DiscordLiveProvider implements DiscordProvider, DiscordDiagnosticProvider {
     #private;
     readonly applicationId: string;
     constructor(options: DiscordLiveProviderOptions);
@@ -64,6 +64,12 @@ export declare class DiscordLiveProvider implements DiscordProvider {
     }): Promise<{
         id: string;
     } | null>;
+    probeConfiguration(signal?: AbortSignal): Promise<DiscordConfigurationProbeResult>;
+    sendOneShotTest(input: {
+        channelId: string;
+        message: string;
+        signal?: AbortSignal;
+    }): Promise<DiscordOneShotTestResult>;
     start(onEvent: (event: DiscordInboundEvent) => Promise<void>): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/types/sdk/bus/discord-provider.d.ts

@@ -36,6 +36,25 @@ export interface DiscordMessageComponent {
         }>;
     }>;
 }
+export interface DiscordConfigurationProbeResult {
+    ok: boolean;
+    detail: string;
+    botUserId?: string;
+}
+export interface DiscordOneShotTestResult {
+    ok: boolean;
+    detail: string;
+    messageId?: string;
+    uncertain?: boolean;
+}
+export interface DiscordDiagnosticProvider {
+    probeConfiguration(signal?: AbortSignal): Promise<DiscordConfigurationProbeResult>;
+    sendOneShotTest(input: {
+        channelId: string;
+        message: string;
+        signal?: AbortSignal;
+    }): Promise<DiscordOneShotTestResult>;
+}
 export interface DiscordProvider {
     readonly applicationId: string;
     readonly botUserId: string;

package/dist/types/sdk/bus/index.d.ts

@@ -337,7 +337,7 @@ interface SessionRuntime {
     notificationRootRegistration?: {
         settings: Settings;
         cwd: string;
-        registrationToken?: string;
+        registrationToken: string;
     };
     verbosity: "lean" | "verbose";
     sessionTag: string;

package/dist/types/sdk/bus/notification-orchestration.d.ts

@@ -1,5 +1,5 @@
 import type { RawSettings, SettingsAtomicPatch, SettingsAtomicReceipt } from "../../config/settings";
-import { type NotificationSettingsReader, type TelegramActivationMarker, type TelegramActivationMarkers, type TelegramActivationReason, type TelegramActivationState, telegramActivationIdentity } from "./config";
+import { type NotificationProvider, type NotificationSettingsReader, type ProviderSecretDisposition, type TelegramActivationMarker, type TelegramActivationMarkers, type TelegramActivationReason, type TelegramActivationState, telegramActivationIdentity } from "./config";
 import { type EnsureTelegramDaemonDetailedResult, type TelegramDaemonFs } from "./telegram-daemon";
 export type { TelegramActivationMarker, TelegramActivationMarkers, TelegramActivationReason, TelegramActivationState };
 export { telegramActivationIdentity };
@@ -41,7 +41,7 @@ export interface ProposedTelegramIdentityPreflightInput {
 export declare function proposedTelegramIdentity(input: ProposedTelegramIdentityPreflightInput): Promise<ProposedTelegramIdentity>;
 export interface NotificationConfigurationWriter extends NotificationSettingsReader {
     commitAtomicBatch(patches: readonly SettingsAtomicPatch[]): Promise<SettingsAtomicReceipt>;
-    commitAtomicBatchWithCurrent?(buildPatches: (current: Readonly<RawSettings>) => Promise<readonly SettingsAtomicPatch[]> | readonly SettingsAtomicPatch[]): Promise<SettingsAtomicReceipt>;
+    commitAtomicBatchWithCurrent(buildPatches: (current: Readonly<RawSettings>) => Promise<readonly SettingsAtomicPatch[]> | readonly SettingsAtomicPatch[]): Promise<SettingsAtomicReceipt>;
 }
 export declare function createTelegramActivationMarker(input: {
     botToken: string;
@@ -55,23 +55,16 @@ export declare function observedTelegramActivationMarker(settings: NotificationS
 export declare function persistTelegramActivationMarker(settings: NotificationConfigurationWriter, marker: TelegramActivationMarker): Promise<SettingsAtomicReceipt>;
 /** Clear only the exact marker that was safely reconciled. */
 export declare function clearTelegramActivationMarker(settings: NotificationConfigurationWriter, marker: TelegramActivationMarker): Promise<void>;
-export type CompleteNonTelegramAdapter = "discord" | "slack";
 export type SaveTelegramInactiveAvailability = {
     available: true;
 };
-/**
- * Telegram-specific activation markers let Save inactive preserve globally
- * enabled Discord and Slack adapters, so the action is always available.
- */
+/** Telegram activation markers make Save inactive independent of sibling providers. */
 export declare function getSaveTelegramInactiveAvailability(_settings: NotificationSettingsReader): SaveTelegramInactiveAvailability;
 export type SaveTelegramInactiveResult = {
     status: "saved_inactive";
     receipt: SettingsAtomicReceipt;
 };
-/**
- * Atomically persist Telegram credentials with a non-secret inactive marker.
- * Global notifications are disabled only when Telegram is the sole complete adapter.
- */
+/** Atomically persist Telegram credentials, desired-off intent, and its inactive marker. */
 export declare function saveTelegramInactive(input: {
     settings: NotificationConfigurationWriter;
     botToken: string;
@@ -117,9 +110,16 @@ export interface TelegramPostCommitActivation {
 }
 export type PostCommitTelegramActivationResult = {
     status: "activated";
-    reconnect: Exclude<TelegramDaemonReconnectOutcome, "blocked_identity">;
+    receipt: SettingsAtomicReceipt;
+    reconnect: Exclude<TelegramDaemonReconnectOutcome, "blocked_identity" | "disabled">;
+} | {
+    status: "activation_failed";
+    receipt: SettingsAtomicReceipt;
+    reconnect?: TelegramDaemonReconnectOutcome;
+    message: string;
 } | {
     status: "blocked_identity";
+    receipt: SettingsAtomicReceipt;
     message: string;
     restore(): Promise<BlockedTelegramRestoreResult>;
     retainCommitted(): void;
@@ -135,12 +135,6 @@ export type BlockedTelegramRestoreResult = {
 } | {
     status: "still_blocked";
 };
-/**
- * Complete a committed Telegram update in the required order: identity
- * reconnect first, normal session reconciliation second. A post-commit foreign
- * owner race stops the endpoint, durably marks only that Telegram identity
- * inactive, then exposes an ordered CAS restore/retain choice.
- */
 export declare function reconcileCommittedTelegramConfiguration(input: {
     receipt: SettingsAtomicReceipt;
     activation: TelegramPostCommitActivation;
@@ -169,3 +163,118 @@ export declare function saveTelegramConfiguration(input: {
     preflight?: (input: Omit<ProposedTelegramIdentityPreflightInput, "settings">) => Promise<ProposedTelegramIdentity>;
     activation?: TelegramPostCommitActivation;
 }): Promise<SaveTelegramConfigurationResult>;
+export type ProviderSecretMutation = {
+    action: "keep";
+} | {
+    action: "replace";
+    value: string;
+} | {
+    action: "remove";
+};
+export interface TelegramProviderConfigurationMutation {
+    provider: "telegram";
+    botToken: ProviderSecretMutation;
+    chatId?: string;
+    richEnabled?: boolean;
+    richDraftEnabled?: boolean;
+    streamingEnabled?: boolean;
+}
+export interface DiscordProviderConfigurationMutation {
+    provider: "discord";
+    botToken: ProviderSecretMutation;
+    applicationId?: string;
+    guildId?: string;
+    parentChannelId?: string;
+}
+export interface SlackProviderConfigurationMutation {
+    provider: "slack";
+    botToken: ProviderSecretMutation;
+    appToken: ProviderSecretMutation;
+    workspaceId?: string;
+    channelId?: string;
+    authorizedUserId?: string | null;
+}
+export type NotificationProviderConfigurationMutation = TelegramProviderConfigurationMutation | DiscordProviderConfigurationMutation | SlackProviderConfigurationMutation;
+export interface NotificationProviderRuntimeAuthority {
+    activate(provider: NotificationProvider): Promise<void>;
+    deactivate(provider: NotificationProvider): Promise<void>;
+}
+export type NotificationProviderMutationResult = {
+    status: "saved";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "activated";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "activation_failed";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "deactivation_failed";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "commit_failed";
+};
+/**
+ * Sole CAS-backed provider configuration authority. It commits one selected-provider
+ * batch before observer/runtime effects and never reports rollback after a durable save.
+ */
+export declare function mutateNotificationProvider(input: {
+    settings: NotificationConfigurationWriter;
+    mutation: NotificationProviderConfigurationMutation;
+    desiredEnabled?: boolean;
+    configureAndActivate?: boolean;
+    notifyConfigChanged?: () => Promise<void> | void;
+    redact?: boolean;
+    runtime?: NotificationProviderRuntimeAuthority;
+    signal?: AbortSignal;
+}): Promise<NotificationProviderMutationResult>;
+export type NotificationProviderRemovalResult = {
+    status: "removed";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "deactivation_failed";
+    receipt?: SettingsAtomicReceipt;
+    observerFailed?: boolean;
+} | {
+    status: "commit_failed_after_teardown";
+} | {
+    status: "commit_failed";
+};
+/** Remove only one provider. Telegram keeps teardown-before-delete; chat providers deactivate after commit. */
+export declare function removeNotificationProvider(input: {
+    settings: NotificationConfigurationWriter;
+    provider: NotificationProvider;
+    runtime: NotificationProviderRuntimeAuthority;
+    notifyConfigChanged?: () => Promise<void> | void;
+}): Promise<NotificationProviderRemovalResult>;
+export type GlobalNotificationMutationResult = {
+    status: "saved";
+    receipt: SettingsAtomicReceipt;
+    observerFailed: boolean;
+} | {
+    status: "global_deactivation_partial";
+    receipt: SettingsAtomicReceipt;
+    failed: readonly NotificationProvider[];
+    observerFailed: boolean;
+} | {
+    status: "global_activation_partial";
+    receipt: SettingsAtomicReceipt;
+    failed: readonly NotificationProvider[];
+    observerFailed: boolean;
+} | {
+    status: "commit_failed";
+};
+/** Toggle only the global master. Provider configuration and desired intent are preserved. */
+export declare function setGlobalNotificationsEnabled(input: {
+    settings: NotificationConfigurationWriter;
+    enabled: boolean;
+    runtime?: NotificationProviderRuntimeAuthority;
+    notifyConfigChanged?: () => Promise<void> | void;
+}): Promise<GlobalNotificationMutationResult>;
+/** Safe helper for UI contracts that must retain only the disposition, never replacement material. */
+export declare function providerSecretDisposition(mutation: ProviderSecretMutation): ProviderSecretDisposition;

package/dist/types/sdk/bus/notification-service.d.ts

@@ -1,5 +1,8 @@
 import type { WriteFileOptions } from "node:fs";
 import type { Settings } from "../../config/settings";
+import { type NotificationProvider, type NotificationRuntime, type ProviderResolution } from "./config";
+import type { DiscordDiagnosticProvider } from "./discord-provider";
+import type { SlackDiagnosticProvider } from "./slack-provider";
 /**
  * Strip secrets from a human-facing diagnostic string. Redacts the configured
  * bot token (exact match) and any token-shaped substring so health/test details
@@ -53,17 +56,34 @@ export interface NotificationServiceDeps {
     pidAlive?: (pid: number) => boolean;
     fetchImpl?: typeof fetch;
     apiBase?: string;
+    createDiscordDiagnostic?: (config: {
+        applicationId: string;
+        botToken: string;
+    }) => DiscordDiagnosticProvider;
+    createSlackDiagnostic?: (config: {
+        appToken: string;
+        botToken: string;
+    }) => SlackDiagnosticProvider;
+    providerRuntimeStatus?: (provider: NotificationProvider) => Promise<NotificationRuntime> | NotificationRuntime;
 }
 export interface AdapterConfigView {
     botTokenMasked: string;
     channel: string | undefined;
     configured: boolean;
+    quarantined: boolean;
+    desiredEnabled: boolean;
+    desiredSource: ProviderResolution["desiredSource"];
+    effectiveEnabled: boolean;
+    issues: ProviderResolution["issues"];
+    runtime?: NotificationRuntime;
 }
 export interface NotificationStatusReport {
     enabled: boolean;
     redact: boolean;
     verbosity: "lean" | "verbose";
     globallyConfigured: boolean;
+    anyProviderComplete: boolean;
+    anyProviderEffective: boolean;
     telegram: AdapterConfigView & {
         tokenFingerprint: string | undefined;
     };
@@ -139,6 +159,8 @@ export interface EndpointHealth {
 export interface NotificationHealthReport {
     overall: HealthLevel;
     configured: boolean;
+    provider?: NotificationProvider;
+    resolution?: ProviderResolution;
     checks: HealthCheck[];
     daemon: DaemonHealth;
     endpoints: EndpointHealth;
@@ -152,8 +174,10 @@ export interface HealthOptions {
     settings: Settings;
     stateRoot?: string;
     deps?: NotificationServiceDeps;
-    /** When true and Telegram is configured, probe the Bot API (getMe) for reachability. */
+    provider?: NotificationProvider;
+    /** When true, use the selected provider's REST-only diagnostic path. */
     probe?: boolean;
+    signal?: AbortSignal;
 }
 /** Structural (offline-by-default) health of the notification subsystem. */
 export declare function checkNotificationHealth(opts: HealthOptions): Promise<NotificationHealthReport>;
@@ -161,16 +185,19 @@ export declare function checkNotificationHealth(opts: HealthOptions): Promise<No
 export declare function formatNotificationHealthReport(report: NotificationHealthReport): string;
 export interface NotificationTestResult {
     ok: boolean;
-    adapter: "telegram";
-    chatId: string | undefined;
+    adapter?: NotificationProvider;
+    destination?: string;
     detail: string;
+    uncertain?: boolean;
 }
 export interface TestOptions {
     settings: Settings;
     deps?: NotificationServiceDeps;
+    provider?: NotificationProvider;
     text?: string;
+    signal?: AbortSignal;
 }
-/** Send a one-off test notification through the configured Telegram adapter. */
+/** Send a one-off test through exactly one durable, effective provider. */
 export declare function sendNotificationTest(opts: TestOptions): Promise<NotificationTestResult>;
 /** Render a test result as a single human-readable line (no secrets). */
 export declare function formatNotificationTestResult(result: NotificationTestResult): string;