@gajae-code/coding-agent 0.12.7 → 0.12.10

package/src/sdk/bus/daemon-paths.ts

@@ -16,6 +16,7 @@ export interface DaemonPaths {
 	ownership: string;
 	roots: string;
 	steal: string;
+	diagnostic: string;
 	aliases: string;
 	seenUpdates: string;
 }
@@ -31,6 +32,7 @@ export function daemonPaths(agentDir: string): DaemonPaths {
 		roots: path.join(dir, "telegram-daemon.roots.json"),
 		steal: path.join(dir, "telegram-daemon.steal"),
 		aliases: path.join(dir, "telegram-callback-aliases.json"),
+		diagnostic: path.join(dir, "telegram-daemon.diagnostics.json"),
 		seenUpdates: path.join(dir, "telegram-seen-updates.json"),
 	};
 }

package/src/sdk/bus/discord-live-provider.ts

@@ -1,4 +1,12 @@
-import type { DiscordInboundEvent, DiscordMessageComponent, DiscordProvider, DiscordThread } from "./discord-provider";
+import type {
+	DiscordConfigurationProbeResult,
+	DiscordDiagnosticProvider,
+	DiscordInboundEvent,
+	DiscordMessageComponent,
+	DiscordOneShotTestResult,
+	DiscordProvider,
+	DiscordThread,
+} from "./discord-provider";
 
 const API_BASE = "https://discord.com/api/v10";
 const GATEWAY_INTENTS = 1 + 512 + 32_768;
@@ -35,7 +43,7 @@ export interface DiscordLiveProviderOptions {
 type JsonRecord = Record<string, unknown>;
 
 /** Discord REST/Gateway implementation. The only credential is held privately and is never emitted. */
-export class DiscordLiveProvider implements DiscordProvider {
+export class DiscordLiveProvider implements DiscordProvider, DiscordDiagnosticProvider {
 	readonly applicationId: string;
 	readonly #token: string;
 	readonly #fetch: DiscordFetch;
@@ -230,6 +238,53 @@ export class DiscordLiveProvider implements DiscordProvider {
 		return null;
 	}
 
+	async probeConfiguration(signal?: AbortSignal): Promise<DiscordConfigurationProbeResult> {
+		if (signal?.aborted) return { ok: false, detail: "Discord configuration probe cancelled." };
+		try {
+			const currentUser = await this.#request("/users/@me", { signal });
+			const botUserId = this.#string(currentUser, "id");
+			if (!botUserId) return { ok: false, detail: "Discord returned an invalid bot identity." };
+			const application = await this.#request("/applications/@me", { signal });
+			const applicationId = this.#string(application, "id");
+			if (!applicationId || applicationId !== this.applicationId) {
+				return { ok: false, detail: "Discord application identity does not match the configured application ID." };
+			}
+			return { ok: true, detail: "Discord bot and application credentials are valid.", botUserId };
+		} catch (error) {
+			if (signal?.aborted) return { ok: false, detail: "Discord configuration probe cancelled." };
+			const detail = error instanceof Error ? error.message : "Discord configuration probe failed.";
+			return { ok: false, detail };
+		}
+	}
+
+	async sendOneShotTest(input: {
+		channelId: string;
+		message: string;
+		signal?: AbortSignal;
+	}): Promise<DiscordOneShotTestResult> {
+		if (input.signal?.aborted) return { ok: false, detail: "Discord notification test cancelled." };
+		try {
+			const response = await this.#request(`/channels/${input.channelId}/messages`, {
+				method: "POST",
+				body: JSON.stringify({ content: input.message }),
+				signal: input.signal,
+			});
+			const messageId = this.#string(response, "id");
+			if (!messageId) {
+				return {
+					ok: false,
+					detail: "Discord may have accepted the message but returned no message receipt.",
+					uncertain: true,
+				};
+			}
+			return { ok: true, detail: "Discord notification test delivered.", messageId };
+		} catch (error) {
+			if (input.signal?.aborted) return { ok: false, detail: "Discord notification test cancelled." };
+			const detail = error instanceof Error ? error.message : "Discord notification test failed.";
+			return { ok: false, detail, uncertain: !detail.startsWith("Discord API request failed") };
+		}
+	}
+
 	async start(onEvent: (event: DiscordInboundEvent) => Promise<void>): Promise<void> {
 		if (!this.#stopped) return;
 		this.#onEvent = onEvent;

package/src/sdk/bus/discord-provider.ts

@@ -31,6 +31,27 @@ 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/src/sdk/bus/index.ts

@@ -67,6 +67,7 @@ import { CursorRegistry, QueryHandlers, RevisionStore, type SessionSurface } fro
 import { projectQ10Models } from "../models.js";
 import { PROMPT_CLIENT_REF_MAX_LENGTH, type SdkPromptTerminalOutcome } from "../prompt-status";
 import { OPERATIONS } from "../protocol/operation-registry";
+import { ActiveProviderResolutionError } from "../providers.js";
 import {
 	lifecycleStartupCapabilityForApi,
 	normalizeSdkStartupFailure,
@@ -75,13 +76,12 @@ import {
 import { registerTelegramFileSink } from "./attachment-registry";
 import { ensureDiscordDaemon, ensureSlackDaemon } from "./chat-daemon-control";
 import {
+	getCurrentTelegramActivationMarker,
 	getNotificationConfig,
-	isDiscordConfigured,
-	isSessionNotificationsEnabled,
-	isSlackConfigured,
-	isTelegramConfigured,
+	isProviderEffectivelyEnabled,
 	type NotificationConfig,
 	type NotificationSettingsReader,
+	resolveGenericNotificationSessionEligibility,
 	sessionTag,
 } from "./config";
 import { telegramControlCommandUsage } from "./config-commands";
@@ -93,6 +93,7 @@ import {
 import { imageAttachmentsFromMessage, notificationActionPayload, summaryFromMessage, truncate } from "./helpers";
 import { createKindAwareReconciliation } from "./kind-aware-reconciliation";
 import { assertNativeRuntimeCompatibility } from "./native-runtime-compatibility";
+import { proposedTelegramIdentity } from "./notification-orchestration";
 import { createPromptReconciliation, sanitizePromptFailure } from "./prompt-reconciliation";
 import { createReconciliationStore } from "./reconciliation-store";
 import { NotificationSessionController, type NotificationSessionRuntime } from "./session-control";
@@ -987,7 +988,7 @@ interface SessionRuntime {
 	serverStopped: boolean;
 	brokerRegistrationReleased: boolean;
 	/** Managed Telegram root registration released during terminal teardown. */
-	notificationRootRegistration?: { settings: Settings; cwd: string; registrationToken?: string };
+	notificationRootRegistration?: { settings: Settings; cwd: string; registrationToken: string };
 	verbosity: "lean" | "verbose";
 	sessionTag: string;
 	/** Whether the agent loop is currently running (drives the typing indicator). */
@@ -2101,6 +2102,13 @@ function sdkQuerySurface(
 			promptTerminalOutcomeVersion: 1,
 		}),
 		getAuthProviders: () => [...new Set(ctx.modelRegistry.getAll().map(model => model.provider))],
+		getActiveProviders: () => {
+			try {
+				return ctx.modelRegistry.getActiveProviders();
+			} catch {
+				throw new ActiveProviderResolutionError();
+			}
+		},
 		getTools: () => {
 			const tools = typeof (ctx as Partial<ExtensionContext>).getAllTools === "function" ? ctx.getAllTools() : [];
 			return tools.length > 0 ? tools : (getInstalledDefinitions("host_tools") ?? []);
@@ -3193,8 +3201,8 @@ export async function ensureConfiguredProviderDaemons(
 		configuredSettings,
 	) => (provider === "discord" ? ensureDiscordDaemon(configuredSettings) : ensureSlackDaemon(configuredSettings)),
 ): Promise<void> {
-	if (isDiscordConfigured(cfg)) await ensureProviderDaemon("discord", settings);
-	if (isSlackConfigured(cfg)) await ensureProviderDaemon("slack", settings);
+	if (isProviderEffectivelyEnabled(cfg, "discord")) await ensureProviderDaemon("discord", settings);
+	if (isProviderEffectivelyEnabled(cfg, "slack")) await ensureProviderDaemon("slack", settings);
 }
 
 /**
@@ -3241,12 +3249,14 @@ export function createNotificationsExtension(
 		new NotificationSessionController({
 			eligible: true,
 			getConfig: () => resolveSettings(options.settings).cfg,
+			spawnedByGjc: options.spawnedByGjc,
 		});
 
 	// Failed terminal teardown remains fenced from normal runtime lookup while the
 	// exact runtime object retains authority for an explicit idempotent retry.
 	const cleanupRetries = new Map<string, SessionRuntime>();
 	const sessionStartPromises = new Map<string, Promise<SessionStartResult>>();
+	const forceIsolatedChatSessions = new Set<string>();
 	const branchStartupTasks = new Set<Promise<void>>();
 	const sessionLifecycleTasks = new Set<Promise<void>>();
 	let activeRuntimeId: string | undefined;
@@ -3285,18 +3295,34 @@ export function createNotificationsExtension(
 			? "blocked_identity"
 			: "ready";
 	}
+	type ConfiguredDaemonOwnerResult = "ready" | "blocked_identity" | "blocked_identity_with_sibling";
 	async function ensureConfiguredDaemonOwners(
 		settings: Settings,
 		cfg: NotificationConfig,
 		cwd: string,
 		id: string,
 		onRegistered?: (registrationToken: string) => void,
-	): Promise<boolean> {
-		if (isTelegramConfigured(cfg)) {
-			if ((await ensureTelegramOwner(settings, cwd, id, onRegistered)) === "blocked_identity") return false;
+	): Promise<ConfiguredDaemonOwnerResult> {
+		if (isProviderEffectivelyEnabled(cfg, "telegram")) {
+			const telegramMarker = getCurrentTelegramActivationMarker(cfg);
+			if (telegramMarker) {
+				if (!isProviderEffectivelyEnabled(cfg, "discord") && !isProviderEffectivelyEnabled(cfg, "slack")) {
+					return "blocked_identity";
+				}
+				await ensureConfiguredProviderDaemons(settings, cfg, options.ensureProviderDaemon);
+				return "blocked_identity_with_sibling";
+			}
+			const telegram = await ensureTelegramOwner(settings, cwd, id, onRegistered);
+			if (telegram === "blocked_identity") {
+				if (!isProviderEffectivelyEnabled(cfg, "discord") && !isProviderEffectivelyEnabled(cfg, "slack")) {
+					return "blocked_identity";
+				}
+				await ensureConfiguredProviderDaemons(settings, cfg, options.ensureProviderDaemon);
+				return "blocked_identity_with_sibling";
+			}
 		}
 		await ensureConfiguredProviderDaemons(settings, cfg, options.ensureProviderDaemon);
-		return true;
+		return "ready";
 	}
 	const identityControlOperations = new Set([
 		"session.new",
@@ -3484,7 +3510,7 @@ export function createNotificationsExtension(
 		const id = sessionId(ctx);
 		const lifecycleRequestId = safeLifecycleRequestId(process.env.GJC_LIFECYCLE_REQUEST_ID);
 		const { settings, cfg, settingsAvailable } = resolveSettings(options.settings);
-		const notificationsEnabledForSession = controller.query(ctx).effectiveEnabled;
+		const notificationsEnabledForSession = controller.query(ctx).genericSessionEnabled;
 		const sdkEnabledForSession =
 			(options.sdkHostModeSupported ?? true) && shouldHostSdk(settings, isNotificationEligibleContext(ctx));
 		const lifecycleRequired = lifecycleStartupCapability !== undefined;
@@ -3525,6 +3551,25 @@ export function createNotificationsExtension(
 		}
 
 		const stateRoot = path.join(ctx.cwd, ".gjc", "state");
+		let isolateChatEndpoint = forceIsolatedChatSessions.delete(id);
+		if (
+			!isolateChatEndpoint &&
+			notificationsEnabledForSession &&
+			settingsAvailable &&
+			settings &&
+			isProviderEffectivelyEnabled(cfg, "telegram") &&
+			(isProviderEffectivelyEnabled(cfg, "discord") || isProviderEffectivelyEnabled(cfg, "slack")) &&
+			typeof cfg.botToken === "string" &&
+			typeof cfg.chatId === "string"
+		) {
+			const marker = getCurrentTelegramActivationMarker(cfg);
+			if (marker) isolateChatEndpoint = true;
+			else {
+				const identity = await proposedTelegramIdentity({ settings, botToken: cfg.botToken, chatId: cfg.chatId });
+				isolateChatEndpoint = identity.status === "foreign" || identity.status === "unknown";
+			}
+		}
+		const endpointStateRoot = isolateChatEndpoint ? path.join(stateRoot, "chat") : stateRoot;
 		const lifecycleAgentDir = lifecycleRequired ? settings?.getAgentDir?.() : undefined;
 		if (lifecycleRequired && !lifecycleAgentDir)
 			return failLifecycleStartup("failed", "Lifecycle SDK startup requires an agent directory.");
@@ -3546,7 +3591,7 @@ export function createNotificationsExtension(
 				nativeVersion: nativeBuildInfo().version,
 				notificationServer: NotificationServer.prototype,
 			});
-			server = new NotificationServer(id, token, stateRoot, true);
+			server = new NotificationServer(id, token, endpointStateRoot, true);
 		} catch (error) {
 			if (lifecycleRequired) return failLifecycleStartup("failed", error);
 			throw error;
@@ -5006,18 +5051,26 @@ export function createNotificationsExtension(
 			if (notificationsEnabledForSession && settingsAvailable && settings) {
 				try {
 					let registrationToken: string | undefined;
-					if (
-						!(await ensureConfiguredDaemonOwners(settings, cfg, ctx.cwd, id, token => {
-							registrationToken = token;
-						}))
-					) {
+					const ownership = await ensureConfiguredDaemonOwners(settings, cfg, ctx.cwd, id, token => {
+						registrationToken = token;
+					});
+					if (ownership === "blocked_identity") {
 						const result = failLifecycleStartup("failed", "Telegram daemon ownership is blocked.");
 						finishStartup(result);
 						await cleanupAbandonedStartup();
 						return result;
 					}
-					if (isTelegramConfigured(cfg))
+					if (ownership === "blocked_identity_with_sibling" && !isolateChatEndpoint) {
+						await cleanupAbandonedStartup();
+						if (sessionStartPromises.get(id) === startSettled.promise) sessionStartPromises.delete(id);
+						forceIsolatedChatSessions.add(id);
+						const result = await startSession(ctx);
+						finishStartup(result);
+						return result;
+					}
+					if (registrationToken !== undefined) {
 						runtime.notificationRootRegistration = { settings, cwd: ctx.cwd, registrationToken };
+					}
 				} catch (error) {
 					const result = failLifecycleStartup("failed", error);
 					finishStartup(result);
@@ -5059,8 +5112,8 @@ export function createNotificationsExtension(
 					throwIfLifecycleStopped();
 					const index = await new SessionIndex(agentDir).open();
 					throwIfLifecycleStopped();
-					const locator = { repo: path.resolve(ctx.cwd), stateRoot };
-					const endpointMtimeMs = fs.statSync(path.join(stateRoot, "sdk", `${id}.json`)).mtimeMs;
+					const locator = { repo: path.resolve(ctx.cwd), stateRoot: endpointStateRoot };
+					const endpointMtimeMs = fs.statSync(path.join(endpointStateRoot, "sdk", `${id}.json`)).mtimeMs;
 					await host.registerWithBroker({
 						// The endpoint is written before registration. Its exact mtime
 						// binds this index generation to that discovery record.
@@ -5294,6 +5347,19 @@ export function createNotificationsExtension(
 			return result.status === "started" || result.status === "already" ? "started" : result.status;
 		},
 		stop: async binding => await stopSession(binding.sessionId, "notifications"),
+		isolateTelegram: async binding => {
+			const runtime = runtimes.get(binding.sessionId);
+			if (runtime) {
+				const stopped = await stopSession(binding.sessionId, "session", runtime);
+				if (!stopped || runtimes.has(binding.sessionId) || cleanupRetries.has(binding.sessionId)) return "failed";
+			}
+			forceIsolatedChatSessions.add(binding.sessionId);
+			const result = await startSession(binding.context);
+			if (result.status !== "started" && result.status !== "already") {
+				forceIsolatedChatSessions.delete(binding.sessionId);
+			}
+			return result.status === "started" || result.status === "already" ? "started" : result.status;
+		},
 		refreshPolicy: (binding, policy) => {
 			const runtime = runtimes.get(binding.sessionId);
 			if (!runtime) return;
@@ -5339,8 +5405,8 @@ export function createNotificationsExtension(
 					registrationToken = token;
 				});
 				const runtime = runtimes.get(binding.sessionId);
-				const configured = isTelegramConfigured(resolveSettings(options.settings).cfg);
-				if (result === "ready" && runtime && !runtime.stopping && configured) {
+				const configured = isProviderEffectivelyEnabled(resolveSettings(options.settings).cfg, "telegram");
+				if (result === "ready" && runtime && !runtime.stopping && configured && registrationToken !== undefined) {
 					runtime.notificationRootRegistration = { settings, cwd: binding.cwd, registrationToken };
 				} else if (registrationToken !== undefined) {
 					await unregisterNotificationRoot({
@@ -5364,11 +5430,14 @@ export function createNotificationsExtension(
 			const id = sessionId(ctx);
 			const command = args.trim().split(/\s+/, 1)[0]?.toLowerCase() || "status";
 			const resolved = resolveSettings(options.settings);
-			const enabledWithoutLocalOff = isSessionNotificationsEnabled({
+			const manualEligibilityEnv =
+				process.env.GJC_NOTIFICATIONS === "0" ? { ...process.env, GJC_NOTIFICATIONS: undefined } : process.env;
+			const enabledWithoutLocalOff = resolveGenericNotificationSessionEligibility({
 				cfg: resolved.cfg,
-				env: process.env,
+				env: manualEligibilityEnv,
 				sessionDisabled: false,
-			});
+				spawnedByGjc: options.spawnedByGjc,
+			}).enabled;
 
 			if (command === "off") {
 				const result = await controller.setLocalEnabled(ctx, false);
@@ -5386,13 +5455,6 @@ export function createNotificationsExtension(
 					ctx.ui.notify("Notifications are disabled for subagent sessions.", "warning");
 					return;
 				}
-				if (process.env.GJC_NOTIFICATIONS === "0") {
-					ctx.ui.notify(
-						"Notifications remain disabled: GJC_NOTIFICATIONS=0 is an authoritative opt-out.",
-						"warning",
-					);
-					return;
-				}
 				if (!enabledWithoutLocalOff) {
 					ctx.ui.notify(
 						"Notifications are not configured. Run `gjc notify setup` or set GJC_NOTIFICATIONS=1.",
@@ -5401,7 +5463,7 @@ export function createNotificationsExtension(
 					return;
 				}
 				const result = await controller.setLocalEnabled(ctx, true);
-				const enabled = result.status.running && result.status.effectiveEnabled;
+				const enabled = result.status.running && result.status.genericSessionEnabled;
 				const rotated = sessionId(ctx) !== id;
 				if (rotated) await stopSession(id);
 				const failed = result.outcome === "failed" || (!enabled && !rotated && activeRuntimeId !== id);
@@ -5426,7 +5488,7 @@ export function createNotificationsExtension(
 			const status = controller.query(ctx);
 			const runtime = runtimes.get(id);
 			ctx.ui.notify(
-				`Notifications ${status.running ? "running" : status.effectiveEnabled ? "enabled" : "disabled"} for this session; redaction ${(runtime?.redact ?? resolved.cfg.redact) ? "on" : "off"}; verbosity ${runtime?.verbosity ?? resolved.cfg.verbosity}${status.locallyEnabled ? "" : "; locally off"}.`,
+				`Notifications ${status.running ? "running" : status.genericSessionEnabled ? "enabled" : "disabled"} for this session; admission ${status.genericEligibilitySource}; redaction ${(runtime?.redact ?? resolved.cfg.redact) ? "on" : "off"}; verbosity ${runtime?.verbosity ?? resolved.cfg.verbosity}${status.locallyEnabled ? "" : "; locally off"}.`,
 				"info",
 			);
 		},