@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/sdk/bus/index.ts

@@ -61,12 +61,13 @@ import { registerAskAnswerSource, registerWorkflowGateEmitterListener } from "..
 import { acpFinalTextFromMessage } from "../acp/final-text";
 import { ensureBroker } from "../broker/ensure";
 import { SessionIndex } from "../broker/session-index";
-import { ReverseLeaseError, SessionSdkHost, shouldHostSdk } from "../host";
+import { SessionSdkHost, shouldHostSdk } from "../host";
 import { type ControlSurface, dispatchControl } from "../host/control";
 import { CursorRegistry, QueryHandlers, RevisionStore, type SessionSurface } from "../host/query";
 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;
@@ -3258,8 +3268,6 @@ export function createNotificationsExtension(
 				awaitStartup: boolean;
 		  }
 		| undefined;
-	const MAX_SYNTHETIC_SEAM_ADMISSIONS = 64;
-	let syntheticSeamAdmissions = 0;
 	let extensionShuttingDown = false;
 
 	async function ensureTelegramOwner(
@@ -3287,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",
@@ -3486,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;
@@ -3527,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.");
@@ -3548,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;
@@ -3569,64 +3612,8 @@ export function createNotificationsExtension(
 		const revisions = new RevisionStore(id, Date.now, { storageDir: stateRoot });
 		let host: SessionSdkHost | undefined;
 		let disposeUiAnswerSource: (() => void) | undefined;
-		let fsClientBridge: ClientBridge | undefined;
-		let terminalClientBridge: ClientBridge | undefined;
-		let terminalPublicationFailedLeaseId: string | undefined;
-		const MAX_PENDING_TERMINAL_CREATIONS = 32;
-		let pendingTerminalCreations = 0;
-		let terminalCreationTail = Promise.resolve();
-		const withTerminalCreationAdmission = async <T>(operation: () => Promise<T>): Promise<T> => {
-			if (pendingTerminalCreations >= MAX_PENDING_TERMINAL_CREATIONS)
-				throw new Error("terminal creation admission limit reached");
-			pendingTerminalCreations++;
-			const previous = terminalCreationTail;
-			const release = Promise.withResolvers<void>();
-			terminalCreationTail = previous.then(() => release.promise);
-			try {
-				await previous;
-				return await operation();
-			} finally {
-				pendingTerminalCreations--;
-				release.resolve();
-			}
-		};
-		const providerLeaseIdentities = new Map<
-			string,
-			{ connectionId: string; connectionGeneration: number; fence: string }
-		>();
-		const refreshSdkClientBridge = () => {
-			if (!fsClientBridge && !terminalClientBridge) {
-				ctx.setSdkClientBridge?.(undefined);
-				return;
-			}
-			const bridge: ClientBridge = {
-				capabilities: {
-					readTextFile: fsClientBridge?.capabilities.readTextFile,
-					writeTextFile: fsClientBridge?.capabilities.writeTextFile,
-					terminal: terminalClientBridge?.capabilities.terminal,
-				},
-				deferAgentInitiatedTurns: true,
-			};
-			if (fsClientBridge?.readTextFile) bridge.readTextFile = fsClientBridge.readTextFile;
-			if (fsClientBridge?.writeTextFile) bridge.writeTextFile = fsClientBridge.writeTextFile;
-			if (terminalClientBridge?.quarantineProviderLease)
-				bridge.quarantineProviderLease = terminalClientBridge.quarantineProviderLease;
-			if (terminalClientBridge?.createTerminal) bridge.createTerminal = terminalClientBridge.createTerminal;
-			ctx.setSdkClientBridge?.(bridge);
-		};
-		const installProviderDefinitions = (
-			capability: string,
-			definitions: unknown,
-			leaseId: string,
-			connectionId: string,
-			connectionGeneration: number,
-		) => {
+		const installProviderDefinitions = (capability: string, definitions: unknown) => {
 			validateProviderDefinitions(capability, definitions);
-			providerLeaseIdentities.set(leaseId, {
-				connectionId,
-				connectionGeneration,
-				fence: `${connectionId}:${connectionGeneration}:${leaseId}`,
-			});
 			if (capability === "permission") {
 				ctx.setSdkPermissionProvider?.(async (toolCall, permissionOptions, signal) => {
 					const result = await host!.reverse.request(
@@ -3664,179 +3651,6 @@ export function createNotificationsExtension(
 				);
 				return;
 			}
-			if (capability === "terminal") {
-				const terminalLeaseId = leaseId;
-				if (!terminalLeaseId) throw new Error("terminal provider lease is unavailable");
-				const terminalProviderIdentity = providerLeaseIdentities.get(terminalLeaseId);
-				if (!terminalProviderIdentity) throw new Error("terminal provider generation is unavailable");
-				if (terminalPublicationFailedLeaseId !== terminalLeaseId) terminalPublicationFailedLeaseId = undefined;
-				const requestTerminal = (
-					method: string,
-					payload: Record<string, unknown>,
-					signal?: AbortSignal,
-					cleanup = false,
-				) =>
-					host!.reverse.request(
-						"terminal",
-						method,
-						payload,
-						signal,
-						terminalLeaseId,
-						cleanup,
-						terminalProviderIdentity.connectionId,
-					);
-				const settleTerminalCleanup = async (
-					method: "terminal.kill" | "terminal.release",
-					terminalId: string,
-				): Promise<boolean> =>
-					await Promise.race([
-						Promise.resolve()
-							.then(() => requestTerminal(method, { terminalId }, AbortSignal.timeout(500), true))
-							.then(
-								() => true,
-								() => false,
-							),
-						Bun.sleep(500).then(() => false),
-					]);
-				terminalClientBridge = {
-					capabilities: { terminal: true },
-					deferAgentInitiatedTurns: true,
-					async quarantineProviderLease(identity, _reason) {
-						if (typeof identity === "string") throw new Error("terminal provider generation is required");
-						if (
-							identity.leaseId !== terminalLeaseId ||
-							identity.connectionId !== terminalProviderIdentity.connectionId ||
-							identity.connectionGeneration !== terminalProviderIdentity.connectionGeneration ||
-							identity.fence !== terminalProviderIdentity.fence
-						)
-							throw new Error("terminal provider lease mismatch");
-						terminalPublicationFailedLeaseId = terminalLeaseId;
-						host!.quarantineProviderLease(identity, "terminal cleanup ownership uncertain");
-					},
-					async createTerminal(params) {
-						return withTerminalCreationAdmission(async () => {
-							if (terminalPublicationFailedLeaseId === terminalLeaseId)
-								throw new Error("terminal provider quarantined after publication failure");
-							if (params.signal?.aborted) throw new Error("terminal creation aborted");
-							const creationAbort = new AbortController();
-							const creationSignal = params.signal
-								? AbortSignal.any([params.signal, creationAbort.signal])
-								: creationAbort.signal;
-							let created: unknown;
-							let creationTimedOut = false;
-							try {
-								created = await Promise.race([
-									requestTerminal(
-										"terminal.create",
-										{
-											command: params.command,
-											...(params.args ? { args: params.args } : {}),
-											...(params.env ? { env: params.env } : {}),
-											...(params.cwd ? { cwd: params.cwd } : {}),
-											...(typeof params.outputByteLimit === "number"
-												? { outputByteLimit: params.outputByteLimit }
-												: {}),
-										},
-										creationSignal,
-									),
-									Bun.sleep(500).then(() => {
-										creationTimedOut = true;
-										creationAbort.abort();
-										throw new Error("terminal creation did not settle within 500ms");
-									}),
-								]);
-							} catch (error) {
-								if (
-									creationSignal.aborted ||
-									(error instanceof ReverseLeaseError && error.code === "payload_too_large")
-								)
-									terminalPublicationFailedLeaseId = terminalLeaseId;
-								if (creationTimedOut) throw new Error("terminal creation did not settle within 500ms");
-								throw error;
-							} finally {
-								creationAbort.abort();
-							}
-							const terminalId =
-								created &&
-								typeof created === "object" &&
-								typeof (created as { terminalId?: unknown }).terminalId === "string"
-									? (created as { terminalId: string }).terminalId
-									: undefined;
-							if (!terminalId) {
-								terminalPublicationFailedLeaseId = terminalLeaseId;
-								throw new Error("terminal provider returned an invalid create response");
-							}
-							const publicationAbort = new AbortController();
-							const publicationSignal = params.signal
-								? AbortSignal.any([params.signal, publicationAbort.signal])
-								: publicationAbort.signal;
-							try {
-								await Promise.race([
-									requestTerminal(
-										"terminal.publish",
-										{ toolCallId: params.toolCallId, terminalId },
-										publicationSignal,
-									),
-									Bun.sleep(500).then(() => {
-										publicationAbort.abort();
-										throw new Error("terminal publication did not settle within 500ms");
-									}),
-								]);
-							} catch (error) {
-								const killed = await settleTerminalCleanup("terminal.kill", terminalId);
-								const released = await settleTerminalCleanup("terminal.release", terminalId);
-								if (!params.signal?.aborted || !killed || !released)
-									terminalPublicationFailedLeaseId = terminalLeaseId;
-								throw error;
-							} finally {
-								publicationAbort.abort();
-							}
-							return {
-								terminalId,
-								providerLeaseId: terminalLeaseId,
-								providerConnectionId: terminalProviderIdentity.connectionId,
-								providerConnectionGeneration: terminalProviderIdentity.connectionGeneration,
-								providerFence: terminalProviderIdentity.fence,
-								async currentOutput() {
-									const output = await requestTerminal("terminal.output", { terminalId });
-									if (
-										!output ||
-										typeof output !== "object" ||
-										typeof (output as { output?: unknown }).output !== "string" ||
-										typeof (output as { truncated?: unknown }).truncated !== "boolean"
-									) {
-										throw new Error("terminal provider returned an invalid output response");
-									}
-									const response = output as { output: string; truncated: boolean; exitStatus?: unknown };
-									return {
-										output: response.output,
-										truncated: response.truncated,
-										exitStatus:
-											response.exitStatus && typeof response.exitStatus === "object"
-												? (response.exitStatus as { exitCode?: number | null; signal?: string | null })
-												: null,
-									};
-								},
-								async waitForExit() {
-									const status = await requestTerminal("terminal.waitForExit", { terminalId });
-									if (!status || typeof status !== "object")
-										throw new Error("terminal provider returned an invalid exit response");
-									const response = status as { exitCode?: number | null; signal?: string | null };
-									return { exitCode: response.exitCode ?? null, signal: response.signal ?? null };
-								},
-								async kill() {
-									await requestTerminal("terminal.kill", { terminalId }, undefined, true);
-								},
-								async release() {
-									await requestTerminal("terminal.release", { terminalId }, undefined, true);
-								},
-							};
-						});
-					},
-				};
-				refreshSdkClientBridge();
-				return;
-			}
 			if (capability !== "fs") return;
 			// Only advertise the methods the client actually declared; a read-only client
 			// must keep using the local write path instead of failing against the bridge.
@@ -3868,17 +3682,11 @@ export function createNotificationsExtension(
 			};
 			if (!canRead) delete bridge.readTextFile;
 			if (!canWrite) delete bridge.writeTextFile;
-			fsClientBridge = bridge;
-			refreshSdkClientBridge();
+			ctx.setSdkClientBridge?.(bridge);
 		};
 		const removeProviderDefinitions = (capability: string) => {
 			if (capability === "permission") ctx.setSdkPermissionProvider?.(undefined);
-			if (capability === "fs") fsClientBridge = undefined;
-			if (capability === "terminal") {
-				terminalClientBridge = undefined;
-				terminalPublicationFailedLeaseId = undefined;
-			}
-			if (capability === "fs" || capability === "terminal") refreshSdkClientBridge();
+			if (capability === "fs") ctx.setSdkClientBridge?.(undefined);
 			if (capability === "ui") {
 				disposeUiAnswerSource?.();
 				disposeUiAnswerSource = undefined;
@@ -3886,12 +3694,6 @@ export function createNotificationsExtension(
 		};
 
 		const hostCapCache = new Map<string, ReadonlySet<string>>();
-		const MAX_PENDING_PROVIDER_RECLAIMS = 64;
-		const pendingProviderReclaims = new Map<
-			string,
-			Array<{ connectionId: string; connectionGeneration: number; frame: Record<string, unknown> }>
-		>();
-		let pendingProviderReclaimCount = 0;
 
 		const configOverrides = new Map<string, unknown>();
 		const configRevision = { current: 0 };
@@ -4445,8 +4247,7 @@ export function createNotificationsExtension(
 		};
 
 		const sendSdkFrame = (connectionId: string, frame: Record<string, unknown>) => {
-			const cancellation = frame.type === "reverse_cancel";
-			if (!cancellation && (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime)) {
+			if (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime) {
 				abandonPromptResponse(connectionId, frame);
 				return;
 			}
@@ -4465,15 +4266,13 @@ export function createNotificationsExtension(
 					abandonPromptResponse(connectionId, frame);
 					throw error;
 				}
-				syntheticSeamAdmissions = Math.max(0, syntheticSeamAdmissions - 1);
-				host?.handleDisconnect(connectionId);
 				return;
 			}
 			try {
 				server.sendTo(connectionId, json);
 			} catch (error) {
+				logger.warn(`sdk: directed response delivery failed for ${connectionId}: ${String(error)}`);
 				abandonPromptResponse(connectionId, frame);
-				logger.warn(`sdk: directed response delivery rejected for ${connectionId}: ${String(error)}`);
 				throw error;
 			}
 		};
@@ -4486,13 +4285,6 @@ export function createNotificationsExtension(
 			connectionCapabilities: connectionId => hostCapCache.get(connectionId),
 			installProviderDefinitions,
 			onProviderDefinitionsRemoved: removeProviderDefinitions,
-			onProviderLeaseRegistered: (lease, connectionGeneration) => {
-				providerLeaseIdentities.set(lease.leaseId, {
-					connectionId: lease.connectionId,
-					connectionGeneration,
-					fence: `${lease.connectionId}:${connectionGeneration}:${lease.leaseId}`,
-				});
-			},
 			onFrame: handler => {
 				inboundSdkFrame = handler;
 				return () => {
@@ -4500,11 +4292,6 @@ export function createNotificationsExtension(
 				};
 			},
 			onRequest: options.onSdkRequest,
-			onFrameOverflow: connectionId => {
-				fencedConnections.add(connectionId);
-				controlSurface.cancelPendingPreflightsForConnection(connectionId);
-				host?.handleDisconnect(connectionId);
-			},
 			beforeControlResponse: async (_connectionId, request, response, sendTerminal) => {
 				if (typeof request.operation !== "string" || !identityControlOperations.has(request.operation)) return;
 				const pending = deferredIdentityRotation;
@@ -4796,47 +4583,6 @@ export function createNotificationsExtension(
 				server.sendTo(connectionId, JSON.stringify({ type: responseType, id, ok: false, error }));
 			} catch {}
 		};
-		const queueExpectedProviderReclaim = (connectionId: string, frame: Record<string, unknown>): boolean => {
-			if (frame.type !== "register_provider") return false;
-			const capability = typeof frame.capability === "string" ? frame.capability : undefined;
-			const expectedLeaseId = typeof frame.expectedLeaseId === "string" ? frame.expectedLeaseId : undefined;
-			if (!capability || !expectedLeaseId) return false;
-			const lease = host?.reverse.getLease(capability);
-			if (!lease || lease.connectionId === connectionId || lease.leaseId !== expectedLeaseId) return false;
-			if (pendingProviderReclaimCount >= MAX_PENDING_PROVIDER_RECLAIMS) return false;
-			const queued = pendingProviderReclaims.get(lease.connectionId) ?? [];
-			if (typeof frame.id === "string" && queued.some(entry => entry.frame.id === frame.id)) return true;
-			const currentGeneration = host?.connectionGeneration(connectionId) ?? 0;
-			if (currentGeneration <= 0) return false;
-			queued.push({ connectionId, connectionGeneration: currentGeneration, frame });
-			pendingProviderReclaims.set(lease.connectionId, queued);
-			pendingProviderReclaimCount++;
-			return true;
-		};
-		const purgeProviderReclaimsForClaimant = (connectionId: string): void => {
-			for (const [incumbentId, queued] of pendingProviderReclaims) {
-				const retained = queued.filter(entry => entry.connectionId !== connectionId);
-				pendingProviderReclaimCount = Math.max(0, pendingProviderReclaimCount - (queued.length - retained.length));
-				if (retained.length === 0) pendingProviderReclaims.delete(incumbentId);
-				else pendingProviderReclaims.set(incumbentId, retained);
-			}
-		};
-		const drainProviderReclaims = (closedConnectionId: string): void => {
-			const queued = pendingProviderReclaims.get(closedConnectionId);
-			if (!queued) return;
-			pendingProviderReclaims.delete(closedConnectionId);
-			pendingProviderReclaimCount = Math.max(0, pendingProviderReclaimCount - queued.length);
-			for (const entry of queued) {
-				if (
-					initializedRuntime.inboundFenced ||
-					initializedRuntime.stopping ||
-					runtimes.get(id) !== initializedRuntime
-				)
-					continue;
-				if (!host?.isConnectionOpen(entry.connectionId, entry.connectionGeneration)) continue;
-				inboundSdkFrame?.(entry.connectionId, entry.frame);
-			}
-		};
 		try {
 			server.onSdkFrame((err, inbound) => {
 				if (err || !inbound) return;
@@ -4844,13 +4590,6 @@ export function createNotificationsExtension(
 					const frame = JSON.parse(inbound.json) as unknown;
 					if (!frame || typeof frame !== "object") return;
 					const typedFrame = frame as Record<string, unknown>;
-					if (!host.isConnectionOpen(inbound.connectionId)) {
-						if (host.connectionGeneration(inbound.connectionId) > 0) {
-							sendEndpointStale(inbound.connectionId, typedFrame);
-							return;
-						}
-						host.handleConnect(inbound.connectionId);
-					}
 					if (inbound.connectionId && fencedConnections.has(inbound.connectionId)) {
 						sendEndpointStale(inbound.connectionId, typedFrame);
 						return;
@@ -4859,7 +4598,6 @@ export function createNotificationsExtension(
 						sendEndpointStale(inbound.connectionId, typedFrame);
 						return;
 					}
-					if (queueExpectedProviderReclaim(inbound.connectionId, typedFrame)) return;
 					if (typedFrame.type === "ephemeral_turn" || typedFrame.type === "ephemeral_turn_cancel") return;
 					if (typedFrame.type === "event_replay") {
 						const capabilities = Array.isArray(typedFrame.capabilities) ? typedFrame.capabilities : [];
@@ -4887,16 +4625,11 @@ export function createNotificationsExtension(
 			server.onConnectionClose((_err, connectionId) => {
 				if (!connectionId) return;
 				controlSurface.cancelPendingPreflightsForConnection(connectionId);
-				try {
-					host.handleDisconnect(connectionId);
-				} finally {
-					drainProviderReclaims(connectionId);
-				}
+				host.handleDisconnect(connectionId);
 				hostCapCache.delete(connectionId);
 				// The socket is gone, so its fence has nothing left to refuse. Dropping the
 				// entry keeps the set bounded by live connections instead of growing forever.
 				fencedConnections.delete(connectionId);
-				purgeProviderReclaimsForClaimant(connectionId);
 				// Deliberate deviation from the plan's "claim prompt_failed on old-owner
 				// disconnect": that would break the shipped Q26 reconnect contract, where a
 				// client may drop its socket and reconcile the still-running prompt without
@@ -5177,9 +4910,7 @@ export function createNotificationsExtension(
 									!suspendedRuntime.stopping &&
 									!suspendedRuntime.policySuspended
 								)
-									if (syntheticSeamAdmissions >= MAX_SYNTHETIC_SEAM_ADMISSIONS) return;
-								syntheticSeamAdmissions++;
-								inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
+									inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
 							});
 						}
 					}
@@ -5188,8 +4919,6 @@ export function createNotificationsExtension(
 				if (inbound.kind === "control_command") {
 					const frame = sdkInboundFrame(inbound.commandJson);
 					if (frame) {
-						if (syntheticSeamAdmissions >= MAX_SYNTHETIC_SEAM_ADMISSIONS) return;
-						syntheticSeamAdmissions++;
 						inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
 						return;
 					}
@@ -5322,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);
@@ -5375,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.
@@ -5610,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;
@@ -5655,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({
@@ -5680,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);
@@ -5702,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.",
@@ -5717,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);
@@ -5742,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",
 			);
 		},