@gajae-code/coding-agent 0.12.7 → 0.12.8

package/src/modes/controllers/selector-controller.ts

@@ -19,7 +19,7 @@ import { GJC_MODEL_ASSIGNMENT_TARGETS, type GjcModelAssignmentTargetId } from ".
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import { selectorHead } from "../../config/model-selector-value";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
-import { type Settings, settings } from "../../config/settings";
+import { type Settings, type SettingsAtomicReceipt, settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
@@ -50,16 +50,29 @@ import {
 	stopInteractiveActivityIndicator,
 	suspendInteractiveActivityIndicator,
 } from "../../modes/types";
-import { getNotificationConfig, isTelegramConfigured, maskToken } from "../../sdk/bus/config";
+import { ChatDaemonController } from "../../sdk/bus/chat-daemon-control";
+import {
+	getCurrentTelegramActivationMarker,
+	getNotificationConfig,
+	isProviderEffectivelyEnabled,
+	isTelegramComplete,
+	maskToken,
+	type NotificationProvider,
+} from "../../sdk/bus/config";
 import {
 	clearTelegramActivationMarker,
 	createTelegramActivationMarker,
+	mutateNotificationProvider,
+	type NotificationProviderConfigurationMutation,
+	type NotificationProviderRuntimeAuthority,
 	observedTelegramActivationMarker,
 	persistTelegramActivationMarker,
 	proposedTelegramIdentity,
 	reconcileCommittedTelegramConfiguration,
+	removeNotificationProvider,
 	removeTelegramConfiguration,
 	saveTelegramInactive,
+	setGlobalNotificationsEnabled,
 } from "../../sdk/bus/notification-orchestration";
 import {
 	buildNotificationStatusReport,
@@ -141,6 +154,7 @@ import { JobsOverlayComponent } from "../components/jobs-overlay";
 import { ModelSelectorComponent } from "../components/model-selector";
 import type {
 	NotificationsEditorOperations,
+	PreparedNotificationProviderConfiguration,
 	PreparedTelegramConfiguration,
 } from "../components/notifications-settings-editor";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
@@ -234,6 +248,7 @@ type TelegramDaemonStopResult = {
 
 export interface NotificationsEditorOperationDependencies {
 	getNotificationConfig: typeof getNotificationConfig;
+	getCurrentTelegramActivationMarker: typeof getCurrentTelegramActivationMarker;
 	maskToken: typeof maskToken;
 	buildNotificationStatusReport: typeof buildNotificationStatusReport;
 	checkNotificationHealth: typeof checkNotificationHealth;
@@ -258,10 +273,12 @@ export interface NotificationsEditorOperationDependencies {
 	reloadTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
 	restartTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
 	stopTelegramDaemon(settings: Settings): Promise<TelegramDaemonStopResult>;
+	providerRuntime?: NotificationProviderRuntimeAuthority;
 }
 
 const notificationEditorOperationDependencies: NotificationsEditorOperationDependencies = {
 	getNotificationConfig,
+	getCurrentTelegramActivationMarker,
 	maskToken,
 	buildNotificationStatusReport,
 	checkNotificationHealth,
@@ -298,9 +315,9 @@ function unavailableNotificationSessionStatus(): NotificationSessionStatus {
 	return {
 		eligible: false,
 		locallyEnabled: true,
-		effectiveEnabled: false,
+		genericSessionEnabled: false,
+		genericEligibilitySource: "none",
 		running: false,
-		environment: "off",
 	};
 }
 
@@ -328,6 +345,10 @@ export function createNotificationsEditorOperations(
 ): NotificationsEditorOperations {
 	const services = { ...notificationEditorOperationDependencies, ...overrides };
 	const drafts = new WeakMap<PreparedTelegramConfiguration, string>();
+	const providerDrafts = new WeakMap<
+		PreparedNotificationProviderConfiguration,
+		{ botToken?: string; appToken?: string }
+	>();
 	const sessionContext = () => ({ sessionManager: ctx.sessionManager });
 	const notifyAfterDurableCommit = async (): Promise<void> => {
 		await ctx.notifyConfigChanged?.();
@@ -340,12 +361,52 @@ export function createNotificationsEditorOperations(
 		});
 	const telegramSetupPreflight = async (): Promise<TelegramSetupPreflight> =>
 		await services.resolveTelegramSetupPreflight(ctx.settings);
+	const providerRuntime: NotificationProviderRuntimeAuthority = services.providerRuntime ?? {
+		activate: async provider => {
+			if (provider === "telegram") {
+				const result = await reconnect();
+				if (result === "blocked_identity" || result === "disabled") {
+					throw new Error("Telegram activation failed after the durable save.");
+				}
+				await ctx.session.notificationSessionController?.reconcileCurrentSession(sessionContext());
+				return;
+			}
+			const result = await new ChatDaemonController(ctx.settings, provider).ensure();
+			if (result === "disabled") throw new Error(`${provider} activation failed after the durable save.`);
+		},
+		deactivate: async provider => {
+			if (provider === "telegram") {
+				const result = await services.stopTelegramDaemon(ctx.settings);
+				if (!result.ok) throw new Error(result.message);
+				await ctx.session.notificationSessionController?.reconcileCurrentSession(sessionContext());
+				return;
+			}
+			const result = await new ChatDaemonController(ctx.settings, provider).stop();
+			if (!result.ok) throw new Error(result.message);
+		},
+	};
 
 	return {
 		loadState: async () => {
 			const config = services.getNotificationConfig(ctx.settings);
+			const status = services.buildNotificationStatusReport(ctx.settings);
+			const runtime = async (provider: NotificationProvider) => {
+				const daemon =
+					provider === "telegram"
+						? await new TelegramDaemonController(ctx.settings).status()
+						: await new ChatDaemonController(ctx.settings, provider).status();
+				return daemon.health === "running" ? "ready" : daemon.health === "not_configured" ? "inactive" : "failed";
+			};
+			const [telegramRuntime, discordRuntime, slackRuntime] = await Promise.all([
+				runtime("telegram"),
+				runtime("discord"),
+				runtime("slack"),
+			]);
+			status.telegram.runtime = telegramRuntime;
+			status.discord.runtime = discordRuntime;
+			status.slack.runtime = slackRuntime;
 			return {
-				status: services.buildNotificationStatusReport(ctx.settings),
+				status,
 				session:
 					ctx.session.notificationSessionController?.query(sessionContext()) ??
 					unavailableNotificationSessionStatus(),
@@ -362,13 +423,14 @@ export function createNotificationsEditorOperations(
 			};
 		},
 
-		refreshHealth: async ({ probe, signal }) => {
+		refreshHealth: async ({ probe, provider, signal }) => {
 			if (signal?.aborted) throw new Error("Notification health refresh cancelled.");
 			try {
 				const input: Parameters<typeof checkNotificationHealth>[0] & { signal?: AbortSignal } = {
 					settings: ctx.settings,
 					stateRoot: path.join(ctx.sessionManager.getCwd(), ".gjc", "state"),
 					probe,
+					provider,
 					signal,
 				};
 				const report = await services.checkNotificationHealth(input);
@@ -390,9 +452,21 @@ export function createNotificationsEditorOperations(
 			}
 		},
 
-		sendTest: async () => {
+		sendTest: async provider => {
 			try {
-				const result = await services.sendNotificationTest({ settings: ctx.settings });
+				const result = await services.sendNotificationTest({
+					settings: ctx.settings,
+					provider,
+					deps: {
+						providerRuntimeStatus: async selected => {
+							const status =
+								selected === "telegram"
+									? await new TelegramDaemonController(ctx.settings).status()
+									: await new ChatDaemonController(ctx.settings, selected).status();
+							return status.health === "running" ? "ready" : "inactive";
+						},
+					},
+				});
 				return {
 					...result,
 					detail: services.sanitizeDiagnostic(
@@ -531,12 +605,14 @@ export function createNotificationsEditorOperations(
 		commitConfigure: async draft => {
 			const token = drafts.get(draft);
 			if (!token) throw new Error("The Telegram setup draft expired. Re-enter the masked bot token.");
+			let receipt: SettingsAtomicReceipt | undefined;
 			try {
 				const inactiveMarkerToClear = observedTelegramActivationMarker(ctx.settings, token, draft.chatId);
-				const receipt = await ctx.settings.commitAtomicBatch([
+				receipt = await ctx.settings.commitAtomicBatch([
 					{ path: "notifications.enabled", op: "set", value: true },
 					{ path: "notifications.telegram.botToken", op: "set", value: token },
 					{ path: "notifications.telegram.chatId", op: "set", value: draft.chatId },
+					{ path: "notifications.telegram.enabled", op: "set", value: true },
 					{ path: "notifications.telegram.rich.enabled", op: "set", value: draft.richEnabled },
 					{ path: "notifications.telegram.richDraft.enabled", op: "set", value: draft.richDraftEnabled },
 					{ path: "notifications.telegram.streaming.enabled", op: "set", value: draft.streamingEnabled },
@@ -571,12 +647,20 @@ export function createNotificationsEditorOperations(
 						marker: activationMarker,
 					},
 				});
-				await notifyAfterDurableCommit();
+				let observerFailed = false;
+				try {
+					await notifyAfterDurableCommit();
+				} catch {
+					observerFailed = true;
+				}
 				if (activation.status === "blocked_identity") {
 					return {
 						status: "blocked_identity" as const,
 						receipt,
-						message: services.sanitizeDiagnostic(activation.message, token),
+						message: services.sanitizeDiagnostic(
+							`${activation.message}${observerFailed ? " The settings observer also failed after the durable commit." : ""}`,
+							token,
+						),
 						restore: async () => {
 							const restored = await activation.restore();
 							if (restored.status === "restored" || restored.status === "still_blocked") {
@@ -587,12 +671,36 @@ export function createNotificationsEditorOperations(
 						retainCommitted: () => activation.retainCommitted(),
 					};
 				}
+				if (activation.status === "activation_failed") {
+					return {
+						status: "activation_failed" as const,
+						receipt,
+						message: services.sanitizeDiagnostic(
+							`${activation.message}${observerFailed ? " The settings observer also failed after the durable commit." : ""}`,
+							token,
+						),
+					};
+				}
+				if (observerFailed) {
+					return {
+						status: "observer_failed" as const,
+						receipt,
+						message: "Telegram configuration was saved and activated, but the settings observer failed.",
+					};
+				}
 				return {
 					status: "saved" as const,
 					receipt,
 					message: services.sanitizeDiagnostic("Telegram configuration saved and reconciled.", token),
 				};
 			} catch (error) {
+				if (receipt) {
+					return {
+						status: "activation_failed" as const,
+						receipt,
+						message: "Telegram configuration was saved, but post-commit activation failed.",
+					};
+				}
 				throw notificationOperationError(services, error, token);
 			}
 		},
@@ -607,7 +715,15 @@ export function createNotificationsEditorOperations(
 					chatId: draft.chatId,
 				});
 				drafts.delete(draft);
-				await notifyAfterDurableCommit();
+				try {
+					await notifyAfterDurableCommit();
+				} catch {
+					return {
+						status: "observer_failed" as const,
+						receipt: result.receipt,
+						message: "Telegram configuration was saved inactive, but the settings observer failed.",
+					};
+				}
 				return {
 					status: "saved_inactive" as const,
 					receipt: result.receipt,
@@ -622,28 +738,289 @@ export function createNotificationsEditorOperations(
 			drafts.delete(draft);
 		},
 
-		enableGlobally: async () => {
-			try {
-				const receipt = await ctx.settings.commitAtomicBatch([
-					{ path: "notifications.enabled", op: "set", value: true },
-				]);
-				await notifyAfterDurableCommit();
-				return { receipt, message: "Global notifications enabled using stored configuration." };
-			} catch (error) {
-				throw notificationOperationError(services, error, services.getNotificationConfig(ctx.settings).botToken);
+		prepareProviderConfiguration: async input => {
+			const cfg = services.getNotificationConfig(ctx.settings);
+			const consumeSecret = (action: typeof input.botToken): string | undefined => {
+				if (!action.value) return undefined;
+				const value = action.value.consume();
+				return action.action === "replace" ? value : undefined;
+			};
+			const botToken = consumeSecret(input.botToken);
+			const appToken = input.appToken ? consumeSecret(input.appToken) : undefined;
+			if (input.botToken.action === "replace" && !botToken?.trim()) {
+				throw new Error("A non-blank bot token replacement is required.");
+			}
+			if (input.provider === "slack" && input.appToken?.action === "replace" && !appToken?.trim()) {
+				throw new Error("A non-blank Slack app token replacement is required.");
 			}
+			if (input.provider === "discord") {
+				const applicationId = input.applicationId?.trim() || undefined;
+				const guildId = input.guildId?.trim() || undefined;
+				const parentChannelId = input.parentChannelId?.trim() || undefined;
+				const resolvedApplicationId = applicationId ?? cfg.discord.applicationId;
+				const resolvedGuildId = guildId ?? cfg.discord.guildId;
+				const resolvedParentChannelId = parentChannelId ?? cfg.discord.parentChannelId;
+				const removesSecret = input.botToken.action === "remove";
+				if (!removesSecret && (!resolvedApplicationId || !resolvedGuildId || !resolvedParentChannelId)) {
+					throw new Error("Discord application, guild, and parent channel IDs are required.");
+				}
+				if (!removesSecret && input.botToken.action === "keep" && !cfg.discord.botToken) {
+					throw new Error("Discord has no stored bot token to keep.");
+				}
+				const draft: PreparedNotificationProviderConfiguration = {
+					provider: "discord",
+					botTokenDisposition: input.botToken.action,
+					botTokenMask: maskToken(botToken ?? cfg.discord.botToken),
+					...(applicationId === undefined ? {} : { applicationId }),
+					...(guildId === undefined ? {} : { guildId }),
+					...(parentChannelId === undefined ? {} : { parentChannelId }),
+					applicationIdDisplay: resolvedApplicationId,
+					guildIdDisplay: resolvedGuildId,
+					parentChannelIdDisplay: resolvedParentChannelId,
+				};
+				providerDrafts.set(draft, { ...(botToken === undefined ? {} : { botToken }) });
+				return draft;
+			}
+			const workspaceId = input.workspaceId?.trim() || undefined;
+			const channelId = input.channelId?.trim() || undefined;
+			const authorizedUserId = input.authorizedUserId?.trim() || undefined;
+			const resolvedWorkspaceId = workspaceId ?? cfg.slack.workspaceId;
+			const resolvedChannelId = channelId ?? cfg.slack.channelId;
+			const resolvedAuthorizedUserId = authorizedUserId ?? cfg.slack.authorizedUserId;
+			const appDisposition = input.appToken?.action ?? "keep";
+			const removesSecret = input.botToken.action === "remove" || appDisposition === "remove";
+			if (!removesSecret && (!resolvedWorkspaceId || !resolvedChannelId)) {
+				throw new Error("Slack workspace and channel IDs are required.");
+			}
+			if (!removesSecret && input.botToken.action === "keep" && !cfg.slack.botToken) {
+				throw new Error("Slack has no stored bot token to keep.");
+			}
+			if (!removesSecret && appDisposition === "keep" && !cfg.slack.appToken) {
+				throw new Error("Slack has no stored app token to keep.");
+			}
+			const draft: PreparedNotificationProviderConfiguration = {
+				provider: "slack",
+				botTokenDisposition: input.botToken.action,
+				botTokenMask: maskToken(botToken ?? cfg.slack.botToken),
+				appTokenDisposition: appDisposition,
+				appTokenMask: maskToken(appToken ?? cfg.slack.appToken),
+				...(workspaceId === undefined ? {} : { workspaceId }),
+				...(channelId === undefined ? {} : { channelId }),
+				...(authorizedUserId === undefined ? {} : { authorizedUserId }),
+				workspaceIdDisplay: resolvedWorkspaceId,
+				channelIdDisplay: resolvedChannelId,
+				authorizedUserIdDisplay: resolvedAuthorizedUserId,
+			};
+			providerDrafts.set(draft, {
+				...(botToken === undefined ? {} : { botToken }),
+				...(appToken === undefined ? {} : { appToken }),
+			});
+			return draft;
 		},
 
-		disableGlobally: async () => {
+		commitProviderConfiguration: async draft => {
+			const secrets = providerDrafts.get(draft) ?? {};
 			try {
-				const receipt = await ctx.settings.commitAtomicBatch([
-					{ path: "notifications.enabled", op: "set", value: false },
-				]);
-				await notifyAfterDurableCommit();
-				return { receipt, message: "Global notifications disabled." };
-			} catch (error) {
-				throw notificationOperationError(services, error, services.getNotificationConfig(ctx.settings).botToken);
+				let mutation: NotificationProviderConfigurationMutation;
+				if (draft.provider === "discord") {
+					mutation = {
+						provider: "discord",
+						botToken:
+							draft.botTokenDisposition === "replace"
+								? { action: "replace", value: secrets.botToken ?? "" }
+								: { action: draft.botTokenDisposition },
+						applicationId: draft.applicationId,
+						guildId: draft.guildId,
+						parentChannelId: draft.parentChannelId,
+					};
+				} else {
+					const appDisposition = draft.appTokenDisposition ?? "keep";
+					mutation = {
+						provider: "slack",
+						botToken:
+							draft.botTokenDisposition === "replace"
+								? { action: "replace", value: secrets.botToken ?? "" }
+								: { action: draft.botTokenDisposition },
+						appToken:
+							appDisposition === "replace"
+								? { action: "replace", value: secrets.appToken ?? "" }
+								: { action: appDisposition },
+						workspaceId: draft.workspaceId,
+						channelId: draft.channelId,
+						authorizedUserId: draft.authorizedUserId,
+					};
+				}
+				const removesSecret = draft.botTokenDisposition === "remove" || draft.appTokenDisposition === "remove";
+				const result = await mutateNotificationProvider({
+					settings: ctx.settings,
+					mutation,
+					configureAndActivate: !removesSecret,
+					...(removesSecret ? { desiredEnabled: false } : {}),
+					notifyConfigChanged: notifyAfterDurableCommit,
+					runtime: providerRuntime,
+				});
+				const outcome =
+					result.status === "commit_failed"
+						? "failed"
+						: result.status === "activation_failed" ||
+								result.status === "deactivation_failed" ||
+								result.observerFailed
+							? "degraded"
+							: "success";
+				const observerSuffix =
+					result.status !== "commit_failed" && result.observerFailed
+						? " The settings observer also failed after the durable commit."
+						: "";
+				return {
+					...(result.status === "commit_failed" ? {} : { receipt: result.receipt }),
+					outcome,
+					message:
+						(result.status === "activated"
+							? `${draft.provider} configuration saved and activated.`
+							: result.status === "activation_failed"
+								? `${draft.provider} configuration and desired intent were saved, but runtime activation failed.`
+								: result.status === "deactivation_failed"
+									? `${draft.provider} desired-off configuration was saved, but runtime deactivation failed.`
+									: result.status === "commit_failed"
+										? `${draft.provider} configuration was not saved because the CAS commit failed.`
+										: `${draft.provider} configuration saved.`) + observerSuffix,
+				};
+			} finally {
+				providerDrafts.delete(draft);
+			}
+		},
+
+		discardProviderConfiguration: draft => {
+			providerDrafts.delete(draft);
+		},
+
+		setProviderDesired: async (provider, enabled) => {
+			if (provider === "telegram" && enabled) {
+				const config = services.getNotificationConfig(ctx.settings);
+				if (services.getCurrentTelegramActivationMarker(config)) {
+					return {
+						outcome: "failed",
+						message:
+							"Telegram remains inactive because its exact activation marker must be restored or cleared after safe owner readiness.",
+					};
+				}
 			}
+			const mutation: NotificationProviderConfigurationMutation =
+				provider === "telegram"
+					? { provider, botToken: { action: "keep" } }
+					: provider === "discord"
+						? { provider, botToken: { action: "keep" } }
+						: { provider, botToken: { action: "keep" }, appToken: { action: "keep" } };
+			const result = await mutateNotificationProvider({
+				settings: ctx.settings,
+				mutation,
+				desiredEnabled: enabled,
+				notifyConfigChanged: notifyAfterDurableCommit,
+				runtime: providerRuntime,
+			});
+			const outcome =
+				result.status === "commit_failed"
+					? "failed"
+					: result.status === "activation_failed" ||
+							result.status === "deactivation_failed" ||
+							result.observerFailed
+						? "degraded"
+						: "success";
+			return {
+				...(result.status === "commit_failed" ? {} : { receipt: result.receipt }),
+				outcome,
+				message:
+					(result.status === "activation_failed"
+						? `${provider} desired intent was saved, but activation failed.`
+						: result.status === "deactivation_failed"
+							? `${provider} desired-off intent was saved, but deactivation failed.`
+							: result.status === "commit_failed"
+								? `${provider} desired intent was not saved because the CAS commit failed.`
+								: `${provider} desired intent ${enabled ? "enabled" : "disabled"}.`) +
+					(result.status !== "commit_failed" && result.observerFailed
+						? " The settings observer also failed after the durable commit."
+						: ""),
+			};
+		},
+
+		removeProvider: async provider => {
+			if (provider === "telegram") {
+				return { message: "Use the Telegram removal action to preserve root-registration fencing." };
+			}
+			const result = await removeNotificationProvider({
+				settings: ctx.settings,
+				provider,
+				runtime: providerRuntime,
+				notifyConfigChanged: notifyAfterDurableCommit,
+			});
+			const degraded =
+				result.status === "deactivation_failed" || ("observerFailed" in result && result.observerFailed);
+			return {
+				...("receipt" in result && result.receipt ? { receipt: result.receipt } : {}),
+				outcome:
+					result.status === "commit_failed" || result.status === "commit_failed_after_teardown"
+						? "failed"
+						: degraded
+							? "degraded"
+							: "success",
+				message:
+					(result.status === "removed"
+						? `${provider} configuration removed.`
+						: result.status === "deactivation_failed"
+							? `${provider} configuration was removed, but runtime deactivation failed.`
+							: `${provider} configuration removal failed.`) +
+					("observerFailed" in result && result.observerFailed
+						? " The settings observer also failed after the durable commit."
+						: ""),
+			};
+		},
+
+		enableGlobally: async () => {
+			const result = await setGlobalNotificationsEnabled({
+				settings: ctx.settings,
+				enabled: true,
+				notifyConfigChanged: notifyAfterDurableCommit,
+				runtime: providerRuntime,
+			});
+			const degraded =
+				result.status === "global_activation_partial" || ("observerFailed" in result && result.observerFailed);
+			return {
+				...(result.status === "commit_failed" ? {} : { receipt: result.receipt }),
+				outcome: result.status === "commit_failed" ? "failed" : degraded ? "degraded" : "success",
+				message:
+					(result.status === "global_activation_partial"
+						? `Global notifications were enabled, but activation failed for ${result.failed.join(", ")}.`
+						: result.status === "commit_failed"
+							? "Global notifications were not enabled because the CAS commit failed."
+							: "Global notifications enabled using stored provider intent.") +
+					(result.status !== "commit_failed" && result.observerFailed
+						? " The settings observer also failed after the durable commit."
+						: ""),
+			};
+		},
+
+		disableGlobally: async () => {
+			const result = await setGlobalNotificationsEnabled({
+				settings: ctx.settings,
+				enabled: false,
+				notifyConfigChanged: notifyAfterDurableCommit,
+				runtime: providerRuntime,
+			});
+			const degraded =
+				result.status === "global_deactivation_partial" || ("observerFailed" in result && result.observerFailed);
+			return {
+				...(result.status === "commit_failed" ? {} : { receipt: result.receipt }),
+				outcome: result.status === "commit_failed" ? "failed" : degraded ? "degraded" : "success",
+				message:
+					(result.status === "global_deactivation_partial"
+						? `Global notifications were disabled, but teardown failed for ${result.failed.join(", ")}.`
+						: result.status === "commit_failed"
+							? "Global notifications were not disabled because the CAS commit failed."
+							: "Global notifications disabled; provider configuration and desired intent were preserved.") +
+					(result.status !== "commit_failed" && result.observerFailed
+						? " The settings observer also failed after the durable commit."
+						: ""),
+			};
 		},
 
 		removeTelegram: async () => {
@@ -676,17 +1053,27 @@ export function createNotificationsEditorOperations(
 						},
 					},
 				});
+				const postCommitFailures: string[] = [];
 				if (runtimePrepared && controller) {
-					await controller.clearBlockedRuntime(sessionContext());
-					await controller.reconcileCurrentSession(sessionContext());
+					try {
+						await controller.clearBlockedRuntime(sessionContext());
+						await controller.reconcileCurrentSession(sessionContext());
+					} catch {
+						postCommitFailures.push("current-session reconciliation failed");
+					}
+				}
+				try {
+					await notifyAfterDurableCommit();
+				} catch {
+					postCommitFailures.push("settings observer failed");
 				}
-				await notifyAfterDurableCommit();
 				return {
 					receipt: result.receipt,
+					outcome: postCommitFailures.length === 0 ? "success" : "degraded",
 					globallyDisabled: result.globallyDisabled,
-					message: result.globallyDisabled
-						? "Telegram configuration removed and global notifications disabled."
-						: "Telegram configuration removed; Discord or Slack configuration was preserved.",
+					message: `Telegram configuration removed without changing the global master.${
+						postCommitFailures.length === 0 ? "" : ` Post-commit ${postCommitFailures.join(" and ")}.`
+					}`,
 				};
 			} catch (error) {
 				if (runtimePrepared) {
@@ -715,7 +1102,10 @@ export function createNotificationsEditorOperations(
 			try {
 				const before = services.getNotificationConfig(ctx.settings);
 				const disablingToolActivity =
-					isTelegramConfigured(before) && before.toolActivity.enabled && !preferences.toolActivityEnabled;
+					isProviderEffectivelyEnabled(before, "telegram") &&
+					isTelegramComplete(before) &&
+					before.toolActivity.enabled &&
+					!preferences.toolActivityEnabled;
 				if (disablingToolActivity) {
 					const stopped = await services.stopTelegramDaemon(ctx.settings);
 					if (!stopped.ok)
@@ -725,7 +1115,7 @@ export function createNotificationsEditorOperations(
 					daemonWasRunningForDisable = stopped.before?.health === "running";
 				}
 
-				let receipt: Awaited<ReturnType<typeof ctx.settings.commitAtomicBatch>>;
+				let receipt: SettingsAtomicReceipt;
 				try {
 					receipt = await ctx.settings.commitAtomicBatch([
 						{ path: "notifications.redact", op: "set", value: preferences.redact },
@@ -758,16 +1148,31 @@ export function createNotificationsEditorOperations(
 					throw error;
 				}
 
+				const postCommitFailures: string[] = [];
 				const config = services.getNotificationConfig(ctx.settings);
-				if (isTelegramConfigured(config)) {
-					const reload = daemonWasRunningForDisable
-						? await services.restartTelegramDaemon(ctx.settings)
-						: await services.reloadTelegramDaemon(ctx.settings);
-					if (!reload.ok)
-						throw new Error(`Notification preferences were saved, but daemon reload failed: ${reload.message}`);
+				if (isProviderEffectivelyEnabled(config, "telegram") && isTelegramComplete(config)) {
+					try {
+						const reload = daemonWasRunningForDisable
+							? await services.restartTelegramDaemon(ctx.settings)
+							: await services.reloadTelegramDaemon(ctx.settings);
+						if (!reload.ok) postCommitFailures.push(`daemon reload failed: ${reload.message}`);
+					} catch {
+						postCommitFailures.push("daemon reload failed");
+					}
+				}
+				try {
+					await notifyAfterDurableCommit();
+				} catch {
+					postCommitFailures.push("settings observer failed");
 				}
-				await notifyAfterDurableCommit();
-				return { receipt, message: "Notification preferences saved atomically." };
+				return {
+					receipt,
+					outcome: postCommitFailures.length === 0 ? "success" : "degraded",
+					message:
+						postCommitFailures.length === 0
+							? "Notification preferences saved atomically."
+							: `Notification preferences were saved, but post-commit ${postCommitFailures.join(" and ")}.`,
+				};
 			} catch (error) {
 				throw notificationOperationError(services, error, services.getNotificationConfig(ctx.settings).botToken);
 			}
@@ -2544,6 +2949,9 @@ export class SelectorController {
 		this.ctx.showStatus(`Logging in to ${providerId}…`);
 		const manualInput = this.ctx.oauthManualInput;
 		const useManualInput = CALLBACK_SERVER_PROVIDERS.has(providerId as OAuthProvider);
+		if (providerId === "opencodex") {
+			this.ctx.showStatus("Checking the local OpenCodex proxy…");
+		}
 		try {
 			await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {
 				onAuth: (info: { url: string; instructions?: string }) => {
@@ -2592,11 +3000,17 @@ export class SelectorController {
 			});
 			await this.ctx.session.modelRegistry.refresh();
 			this.ctx.chatContainer.addChild(new Spacer(1));
-			this.ctx.chatContainer.addChild(
-				new Text(theme.fg("success", `${theme.status.success} Successfully logged in to ${providerId}`), 1, 0),
-			);
-			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0));
-			await this.#handlePostLoginModelProfileRecommendation(providerId);
+			const successMessage =
+				providerId === "opencodex"
+					? `${theme.status.success} OpenCodex proxy status checked`
+					: `${theme.status.success} Successfully logged in to ${providerId}`;
+			this.ctx.chatContainer.addChild(new Text(theme.fg("success", successMessage), 1, 0));
+			if (providerId !== "opencodex") {
+				this.ctx.chatContainer.addChild(
+					new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0),
+				);
+				await this.#handlePostLoginModelProfileRecommendation(providerId);
+			}
 			this.ctx.ui.requestRender();
 		} catch (error: unknown) {
 			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);