@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/sdk/bus/session-control.ts

@@ -1,9 +1,10 @@
 import {
+	type GenericNotificationSessionSource,
 	getCurrentTelegramActivationMarker,
-	isNotificationStreamingEnabled,
-	isSessionNotificationsEnabled,
-	isTelegramConfigured,
+	isProviderEffectivelyEnabled,
 	type NotificationConfig,
+	resolveGenericNotificationSessionEligibility,
+	resolveGenericNotificationStreamPolicy,
 } from "./config";
 
 /** Minimal session-manager surface shared by extension, TUI, and headless hosts. */
@@ -39,6 +40,8 @@ export interface NotificationSessionRuntime<Context extends NotificationSessionC
 	 * emit a frame. `blocked_identity` is fail-closed and starts nothing.
 	 */
 	ensureTelegramDaemon?(binding: BoundNotificationSession<Context>): Promise<TelegramDaemonPreflightResult>;
+	/** Rotates a running/default endpoint into Telegram-isolated chat scope. */
+	isolateTelegram?(binding: BoundNotificationSession<Context>): Promise<NotificationEndpointStartResult>;
 	/** Refresh mutable delivery policy from the same configuration snapshot used for reconciliation. */
 	refreshPolicy?(binding: BoundNotificationSession<Context>, policy: NotificationRuntimePolicy): void;
 	/** Enables delivery only after the controller has committed a stable policy. */
@@ -48,9 +51,9 @@ export interface NotificationSessionRuntime<Context extends NotificationSessionC
 export interface NotificationSessionStatus {
 	eligible: boolean;
 	locallyEnabled: boolean;
-	effectiveEnabled: boolean;
+	genericSessionEnabled: boolean;
+	genericEligibilitySource: GenericNotificationSessionSource;
 	running: boolean;
-	environment: "off" | "explicit" | "token" | "default";
 }
 
 export interface NotificationSessionReconcileResult {
@@ -61,6 +64,7 @@ export interface NotificationSessionReconcileResult {
 export interface NotificationRuntimePolicy {
 	redact: boolean;
 	verbosity: NotificationConfig["verbosity"];
+	/** Generic live-frame delivery policy; never proof of provider effectiveness. */
 	stream: boolean;
 	mode: "provisional" | "committed";
 }
@@ -72,14 +76,16 @@ export interface NotificationSessionControllerOptions {
 	getConfig(): NotificationConfig;
 	/** Kept as a reference so test and embedding hosts can supply their own environment. */
 	env?: NodeJS.ProcessEnv;
+	/** This process was launched by a marked GJC child spawn site. */
+	spawnedByGjc?: boolean;
 }
 
 /**
  * Shared owner of notification session policy.
  *
- * Gate A is captured at creation. Gate B is evaluated for each session
- * operation with `isSessionNotificationsEnabled`. Gate C verifies complete
- * Telegram ownership before a generic endpoint is allowed to start.
+ * Gate A is captured at creation. Gate B is evaluated through the typed generic
+ * session policy. Provider effectiveness remains separate; Telegram owner proof
+ * runs only when Telegram is effective and has no inactive marker.
  */
 const MAX_RECONCILE_ATTEMPTS = 3;
 
@@ -87,7 +93,10 @@ export class NotificationSessionController {
 	readonly #eligible: boolean;
 	readonly #getConfig: () => NotificationConfig;
 	readonly #env: NodeJS.ProcessEnv;
+	readonly #spawnedByGjc: boolean;
 	readonly #disabledSessions = new Set<string>();
+	/** Explicit per-session opt-in overrides only the generic GJC_NOTIFICATIONS=0 auto-admission suppression. */
+	readonly #manualOptInSessions = new Set<string>();
 	/** Sessions held inactive after a post-commit foreign daemon identity race. */
 	readonly #blockedRuntimeSessions = new Set<string>();
 	/** Sessions closed during host shutdown; no queued operation may restart them. */
@@ -100,6 +109,7 @@ export class NotificationSessionController {
 		this.#eligible = options.eligible;
 		this.#getConfig = options.getConfig;
 		this.#env = options.env ?? process.env;
+		this.#spawnedByGjc = options.spawnedByGjc ?? false;
 	}
 
 	/** Attach the concrete generic endpoint implementation used by this host. */
@@ -140,6 +150,7 @@ export class NotificationSessionController {
 	rekeySession(previousSessionId: string, nextSessionId: string): void {
 		if (previousSessionId === nextSessionId) return;
 		if (this.#disabledSessions.delete(previousSessionId)) this.#disabledSessions.add(nextSessionId);
+		if (this.#manualOptInSessions.delete(previousSessionId)) this.#manualOptInSessions.add(nextSessionId);
 		if (this.#blockedRuntimeSessions.delete(previousSessionId)) this.#blockedRuntimeSessions.add(nextSessionId);
 		if (this.#shuttingDownSessions.delete(previousSessionId)) this.#shuttingDownSessions.add(nextSessionId);
 
@@ -186,6 +197,38 @@ export class NotificationSessionController {
 			return await this.#enqueue(binding, async () => {
 				const runtime = this.#runtime as NotificationSessionRuntime<Context> | undefined;
 				this.#refreshPolicy(runtime, binding, { redact: true, verbosity: "lean", stream: false }, "provisional");
+				let preserveSafeSibling = false;
+				try {
+					const cfg = this.#getConfig();
+					preserveSafeSibling =
+						isProviderEffectivelyEnabled(cfg, "discord") || isProviderEffectivelyEnabled(cfg, "slack");
+				} catch {
+					preserveSafeSibling = false;
+				}
+				if (preserveSafeSibling && runtime?.isolateTelegram) {
+					this.#blockedRuntimeSessions.add(binding.sessionId);
+					const outcome = await runtime.isolateTelegram(binding);
+					if (outcome === "started" || outcome === "already") {
+						this.#blockedRuntimeSessions.delete(binding.sessionId);
+						const cfg = this.#getConfig();
+						this.#refreshPolicy(
+							runtime,
+							binding,
+							{
+								redact: cfg.redact,
+								verbosity: cfg.verbosity,
+								stream: resolveGenericNotificationStreamPolicy({
+									cfg,
+									env: this.#env,
+									genericSessionEnabled: true,
+								}).enabled,
+							},
+							"committed",
+						);
+						runtime.activate?.(binding);
+						return true;
+					}
+				}
 				if (runtime?.isRunning(binding)) {
 					const stopped = await runtime.stop(binding);
 					if (!stopped || runtime.isRunning(binding)) {
@@ -222,8 +265,10 @@ export class NotificationSessionController {
 				if (enabled) {
 					this.#disabledSessions.delete(binding.sessionId);
 					this.#shuttingDownSessions.delete(binding.sessionId);
+					this.#manualOptInSessions.add(binding.sessionId);
 				} else {
 					this.#disabledSessions.add(binding.sessionId);
+					this.#manualOptInSessions.delete(binding.sessionId);
 				}
 				return await this.#reconcile(binding);
 			});
@@ -256,49 +301,65 @@ export class NotificationSessionController {
 				if (runtime?.isRunning(binding)) await runtime.stop(binding);
 				return { outcome: "failed", status: this.#failClosedStatus(binding, runtime) };
 			}
+			const nonTelegramEffective =
+				isProviderEffectivelyEnabled(cfg, "discord") || isProviderEffectivelyEnabled(cfg, "slack");
+			if (nonTelegramEffective) this.#blockedRuntimeSessions.delete(binding.sessionId);
 			const status = this.#status(binding, cfg, runtime);
-			if (!status.effectiveEnabled) {
+			if (!status.genericSessionEnabled) {
 				if (runtime && status.running) await runtime.stop(binding);
 				if (!this.#isCurrentConfig(cfg)) continue;
 				return { outcome: status.running ? "stopped" : "disabled", status: this.#status(binding, cfg, runtime) };
 			}
 
 			if (!runtime) return { outcome: "disabled", status };
-			if (getCurrentTelegramActivationMarker(cfg)) {
+			const telegramMarker = getCurrentTelegramActivationMarker(cfg);
+			const telegramEffective = isProviderEffectivelyEnabled(cfg, "telegram");
+			const nonTelegramEffectiveForTelegram =
+				isProviderEffectivelyEnabled(cfg, "discord") || isProviderEffectivelyEnabled(cfg, "slack");
+			if (telegramEffective && telegramMarker && !nonTelegramEffectiveForTelegram) {
 				if (runtime.isRunning(binding)) await runtime.stop(binding);
-				this.#blockedRuntimeSessions.add(binding.sessionId);
 				if (!this.#isCurrentConfig(cfg)) continue;
 				return { outcome: "disabled", status: this.#status(binding, cfg, runtime) };
 			}
-			if (isTelegramConfigured(cfg)) {
+			if (telegramEffective && !telegramMarker) {
+				let ensured: TelegramDaemonPreflightResult | undefined;
 				try {
-					const ensured = await runtime.ensureTelegramDaemon?.(binding);
-					if (!this.#isCurrentConfig(cfg)) continue;
-					if (ensured !== "ready") {
-						if (runtime.isRunning(binding)) await runtime.stop(binding);
-						this.#blockedRuntimeSessions.add(binding.sessionId);
-						return {
-							outcome: ensured === "failed" ? "failed" : "disabled",
-							status: this.#status(binding, cfg, runtime),
-						};
-					}
+					ensured = await runtime.ensureTelegramDaemon?.(binding);
 				} catch {
-					if (!this.#isCurrentConfig(cfg)) continue;
+					ensured = "failed";
+				}
+				if (!this.#isCurrentConfig(cfg)) continue;
+				if (ensured !== "ready" && !nonTelegramEffectiveForTelegram) {
 					if (runtime.isRunning(binding)) await runtime.stop(binding);
 					this.#blockedRuntimeSessions.add(binding.sessionId);
-					return { outcome: "failed", status: this.#status(binding, cfg, runtime) };
+					return {
+						outcome: ensured === "failed" ? "failed" : "disabled",
+						status: this.#status(binding, cfg, runtime),
+					};
+				}
+				if (ensured !== "ready" && nonTelegramEffectiveForTelegram) {
+					const isolated = await runtime.isolateTelegram?.(binding);
+					if (isolated !== "started" && isolated !== "already") {
+						if (runtime.isRunning(binding)) await runtime.stop(binding);
+						this.#blockedRuntimeSessions.add(binding.sessionId);
+						return { outcome: "failed", status: this.#status(binding, cfg, runtime) };
+					}
 				}
 			}
 
 			const current = this.#status(binding, cfg, runtime);
-			if (!current.effectiveEnabled || !this.#isCurrentConfig(cfg)) continue;
+			if (!current.genericSessionEnabled || !this.#isCurrentConfig(cfg)) continue;
 			this.#refreshPolicy(
 				runtime,
 				binding,
 				{
 					redact: cfg.redact,
 					verbosity: cfg.verbosity,
-					stream: isNotificationStreamingEnabled({ cfg, env: this.#env }),
+					stream: resolveGenericNotificationStreamPolicy({
+						cfg,
+						env: this.#env,
+						genericSessionEnabled: current.genericSessionEnabled,
+					}).enabled,
 				},
 				"committed",
 			);
@@ -311,7 +372,11 @@ export class NotificationSessionController {
 				{
 					redact: cfg.redact,
 					verbosity: cfg.verbosity,
-					stream: isNotificationStreamingEnabled({ cfg, env: this.#env }),
+					stream: resolveGenericNotificationStreamPolicy({
+						cfg,
+						env: this.#env,
+						genericSessionEnabled: current.genericSessionEnabled,
+					}).enabled,
 				},
 				"committed",
 			);
@@ -325,7 +390,7 @@ export class NotificationSessionController {
 			}
 			runtime.activate?.(binding);
 			const afterStart = this.#status(binding, cfg, runtime);
-			if (!afterStart.effectiveEnabled) {
+			if (!afterStart.genericSessionEnabled) {
 				if (afterStart.running) await runtime.stop(binding);
 				return {
 					outcome: afterStart.running ? "stopped" : "disabled",
@@ -357,9 +422,9 @@ export class NotificationSessionController {
 		return {
 			eligible: this.#eligible,
 			locallyEnabled: false,
-			effectiveEnabled: false,
+			genericSessionEnabled: false,
+			genericEligibilitySource: "none",
 			running: runtime?.isRunning(binding) ?? false,
-			environment: "off",
 		};
 	}
 
@@ -414,26 +479,36 @@ export class NotificationSessionController {
 		const locallyEnabled = !this.#disabledSessions.has(binding.sessionId);
 		const blockedRuntime = this.#blockedRuntimeSessions.has(binding.sessionId);
 		const shuttingDown = this.#shuttingDownSessions.has(binding.sessionId);
-		const effectiveEnabled =
-			!blockedRuntime &&
+		const manualOptIn = this.#manualOptInSessions.has(binding.sessionId);
+		const eligibilityEnv =
+			manualOptIn && this.#env.GJC_NOTIFICATIONS === "0"
+				? { ...this.#env, GJC_NOTIFICATIONS: undefined }
+				: this.#env;
+		const eligibility = resolveGenericNotificationSessionEligibility({
+			cfg,
+			env: eligibilityEnv,
+			sessionDisabled: !locallyEnabled,
+			spawnedByGjc: this.#spawnedByGjc,
+		});
+		const telegramMarkerBlocksOnlyProvider =
+			Boolean(getCurrentTelegramActivationMarker(cfg)) &&
+			isProviderEffectivelyEnabled(cfg, "telegram") &&
+			!isProviderEffectivelyEnabled(cfg, "discord") &&
+			!isProviderEffectivelyEnabled(cfg, "slack");
+		const telegramBlockedWithoutSibling =
+			blockedRuntime && !isProviderEffectivelyEnabled(cfg, "discord") && !isProviderEffectivelyEnabled(cfg, "slack");
+		const genericSessionEnabled =
+			!telegramBlockedWithoutSibling &&
 			!shuttingDown &&
-			!getCurrentTelegramActivationMarker(cfg) &&
+			!telegramMarkerBlocksOnlyProvider &&
 			this.#eligible &&
-			isSessionNotificationsEnabled({ cfg, env: this.#env, sessionDisabled: !locallyEnabled });
-		const environment =
-			this.#env.GJC_NOTIFICATIONS === "0"
-				? "off"
-				: this.#env.GJC_NOTIFICATIONS === "1"
-					? "explicit"
-					: this.#env.GJC_NOTIFICATIONS_TOKEN
-						? "token"
-						: "default";
+			eligibility.enabled;
 		return {
 			eligible: this.#eligible,
 			locallyEnabled,
-			effectiveEnabled,
+			genericSessionEnabled,
+			genericEligibilitySource: eligibility.source,
 			running: runtime?.isRunning(binding) ?? false,
-			environment,
 		};
 	}
 }

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

@@ -1,5 +1,8 @@
 import type {
+	SlackConfigurationProbeResult,
+	SlackDiagnosticProvider,
 	SlackMessageSearchResult,
+	SlackOneShotTestResult,
 	SlackPostedMessage,
 	SlackProviderClient,
 	SlackSocketEnvelope,
@@ -69,6 +72,8 @@ type SlackApiResponse = {
 	message?: unknown;
 	messages?: unknown;
 	retry_after?: unknown;
+	team_id?: unknown;
+	user_id?: unknown;
 };
 
 function string(value: unknown): string | undefined {
@@ -96,7 +101,7 @@ function socketFromGlobal(url: string): SlackWebSocket {
  * Production Socket Mode and Web API client. It keeps all connection state in
  * memory and deliberately never maintains a Slack cursor.
  */
-export class SlackLiveProvider implements SlackProviderClient {
+export class SlackLiveProvider implements SlackProviderClient, SlackDiagnosticProvider {
 	readonly #appToken: string;
 	readonly #botToken: string;
 	readonly #fetch: (input: string, init?: RequestInit) => Promise<Response>;
@@ -140,6 +145,68 @@ export class SlackLiveProvider implements SlackProviderClient {
 		this.#activityTimeoutMs = Math.max(1, options.activityTimeoutMs ?? 60_000);
 	}
 
+	async probeConfiguration(signal?: AbortSignal): Promise<SlackConfigurationProbeResult> {
+		if (signal?.aborted) return { ok: false, detail: "Slack configuration probe cancelled." };
+		try {
+			const bot = await this.#request("auth.test", this.#botToken, {}, false, signal);
+			if (bot.ok !== true) return { ok: false, detail: "Slack bot token authorization failed." };
+			const app = await this.#request("apps.connections.open", this.#appToken, {}, false, signal);
+			if (app.ok !== true || !string(app.url)) {
+				return { ok: false, detail: "Slack app token Socket Mode authorization failed." };
+			}
+			return {
+				ok: true,
+				detail: "Slack bot and app credentials are valid.",
+				teamId: string(bot.team_id),
+				userId: string(bot.user_id),
+			};
+		} catch (error) {
+			if (signal?.aborted) return { ok: false, detail: "Slack configuration probe cancelled." };
+			return { ok: false, detail: error instanceof Error ? error.message : "Slack configuration probe failed." };
+		}
+	}
+
+	async sendOneShotTest(input: {
+		channel: string;
+		message: string;
+		idempotencyKey: string;
+		signal?: AbortSignal;
+	}): Promise<SlackOneShotTestResult> {
+		if (input.signal?.aborted) return { ok: false, detail: "Slack notification test cancelled." };
+		try {
+			const response = await this.#request(
+				"chat.postMessage",
+				this.#botToken,
+				{ channel: input.channel, text: input.message, client_msg_id: input.idempotencyKey },
+				true,
+				input.signal,
+			);
+			if (response.ok !== true) throw new SlackProviderError("web_api", "chat.postMessage");
+			const posted = this.#message(response);
+			if (!posted) {
+				return {
+					ok: false,
+					detail: "Slack may have accepted the message but returned no message receipt.",
+					uncertain: true,
+				};
+			}
+			return {
+				ok: true,
+				detail: "Slack notification test delivered.",
+				channel: posted.channel,
+				timestamp: posted.ts,
+			};
+		} catch (error) {
+			if (input.signal?.aborted) return { ok: false, detail: "Slack notification test cancelled." };
+			const uncertain = error instanceof SlackProviderError && error.mayHaveBeenAccepted;
+			return {
+				ok: false,
+				detail: error instanceof Error ? error.message : "Slack notification test failed.",
+				...(uncertain ? { uncertain: true } : {}),
+			};
+		}
+	}
+
 	async start(onEnvelope: (envelope: SlackSocketEnvelope) => void | Promise<void>): Promise<void> {
 		this.#lifecycleGeneration++;
 		this.#onEnvelope = onEnvelope;
@@ -310,17 +377,26 @@ export class SlackLiveProvider implements SlackProviderClient {
 		token: string,
 		body: Record<string, string | undefined>,
 		retryRateLimit = false,
+		signal?: AbortSignal,
 	): Promise<SlackApiResponse> {
 		for (let attempt = 0; ; attempt++) {
+			signal?.throwIfAborted();
 			let response: Response;
 			try {
 				response = await this.#fetch(`${SLACK_API}/${operation}`, {
 					method: "POST",
 					headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
 					body: JSON.stringify(body),
+					signal,
 				});
 			} catch {
-				throw new SlackProviderError("connection", operation);
+				throw new SlackProviderError(
+					"connection",
+					operation,
+					undefined,
+					undefined,
+					operation === "chat.postMessage",
+				);
 			}
 			let parsed: unknown;
 			try {

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

@@ -15,6 +15,30 @@ export interface SlackMessageSearchResult {
 	client_msg_id?: string;
 }
 
+export interface SlackConfigurationProbeResult {
+	ok: boolean;
+	detail: string;
+	teamId?: string;
+	userId?: string;
+}
+
+export interface SlackOneShotTestResult {
+	ok: boolean;
+	detail: string;
+	channel?: string;
+	timestamp?: string;
+	uncertain?: boolean;
+}
+
+export interface SlackDiagnosticProvider {
+	probeConfiguration(signal?: AbortSignal): Promise<SlackConfigurationProbeResult>;
+	sendOneShotTest(input: {
+		channel: string;
+		message: string;
+		idempotencyKey: string;
+		signal?: AbortSignal;
+	}): Promise<SlackOneShotTestResult>;
+}
 /** Minimal Socket Mode + Web API seam. Implementations may wrap the official Slack SDK. */
 export interface SlackProviderClient {
 	start(onEnvelope: (envelope: SlackSocketEnvelope) => void | Promise<void>): Promise<void>;

package/src/sdk/bus/telegram-daemon-cli.ts

@@ -6,7 +6,8 @@ import { applyAtomicYamlPatches, setByPath } from "../../config/atomic-yaml-patc
 import type { Settings } from "../../config/settings";
 import {
 	getNotificationConfig,
-	isTelegramConfigured,
+	isProviderEffectivelyEnabled,
+	isTelegramComplete,
 	type NotificationSettingsReader,
 	parseNotificationSettingsSnapshot,
 } from "./config";
@@ -76,6 +77,8 @@ export function createLightweightDaemonSettings(input: {
 			switch (pathName) {
 				case "notifications.enabled":
 					return snapshot.enabled;
+				case "notifications.telegram.enabled":
+					return snapshot.telegram.enabled;
 				case "notifications.telegram.botToken":
 					return snapshot.telegram.botToken;
 				case "notifications.telegram.chatId":
@@ -84,6 +87,8 @@ export function createLightweightDaemonSettings(input: {
 					return snapshot.telegram.btw.enabled;
 				case "notifications.telegram.streaming.enabled":
 					return snapshot.telegram.streaming.enabled;
+				case "notifications.discord.enabled":
+					return snapshot.discord.enabled;
 				case "notifications.discord.botToken":
 					return snapshot.discord.botToken;
 				case "notifications.discord.applicationId":
@@ -92,6 +97,8 @@ export function createLightweightDaemonSettings(input: {
 					return snapshot.discord.guildId;
 				case "notifications.discord.parentChannelId":
 					return snapshot.discord.parentChannelId;
+				case "notifications.slack.enabled":
+					return snapshot.slack.enabled;
 				case "notifications.slack.botToken":
 					return snapshot.slack.botToken;
 				case "notifications.slack.appToken":
@@ -223,7 +230,7 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 	const resolvedAgentDir = agentDir ?? process.env.GJC_CODING_AGENT_DIR ?? path.join(process.cwd(), ".gjc", "agent");
 	const settings = await resolveDaemonSettings(resolvedAgentDir, deps);
 	const cfg = getNotificationConfig(settings);
-	if (!isTelegramConfigured(cfg)) return;
+	if (!isProviderEffectivelyEnabled(cfg, "telegram") || !isTelegramComplete(cfg)) return;
 	const Daemon: TelegramDaemonConstructor = deps.DaemonImpl ?? TelegramNotificationDaemon;
 	const readState = deps.readDaemonState ?? readDaemonState;
 	const daemon = new Daemon({

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -49,11 +49,16 @@ export const NOTIFICATION_PROTOCOL_VERSION = 3;
  * user-created topic adoption (forum-topic folder picker). Generation 36 bound
  * managed-session replacement to exact native filesystem authority; generation
  * 37 retires that binding (revert of #3489, which stalled POSIX artifact
- * cleanup); generation 38 binds exact cleanup to parent and link-count authority;
- * generation 39 hardens exact Bash process-tree ownership, settlement, and
- * descendant cleanup authority.
+ * cleanup); generation 38 binds exact cleanup to parent and link-count authority.
+ * Generation 39 applies rustfmt and clippy-equivalent cleanup to the pi-shell
+ * process-tree authority (#3682); generation 40 hardens exact Bash process-tree
+ * ownership, settlement, and descendant cleanup authority. Generation 38 also
+ * adds durable provider-intent admission without changing owner, reclaim,
+ * signal, or spawn authority.
+ * Generation 41 applies first-class provider-settings admission to Telegram
+ * lifecycle controls.
  */
-export const DAEMON_GENERATION = 39;
+export const DAEMON_GENERATION = 41;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers

package/src/sdk/bus/telegram-daemon-control.ts

@@ -26,7 +26,7 @@ import { OWNERSHIP_MISMATCH_MESSAGE, ownershipMismatchRecovery } from "../../dae
 import { resolveGjcRuntimeSpawnInfo } from "../../daemon/runtime";
 import { isProcessIncarnation } from "../broker/process-incarnation";
 
-import { getNotificationConfig, isTelegramConfigured, tokenFingerprint } from "./config";
+import { getNotificationConfig, isTelegramComplete, tokenFingerprint } from "./config";
 import { exactUnlinkNotificationFile, readNotificationEndpointFile } from "./notification-service";
 import {
 	type AttestedLegacyDaemonOwner,
@@ -221,7 +221,7 @@ export class TelegramDaemonController implements BuiltInDaemonController {
 	async status(): Promise<DaemonStatus> {
 		const runtime = this.runtimeInfo();
 		const cfg = getNotificationConfig(this.settings);
-		const configured = isTelegramConfigured(cfg);
+		const configured = isTelegramComplete(cfg);
 		if (!configured) {
 			return { kind: this.kind, configured: false, health: "not_configured", runtime };
 		}
@@ -369,7 +369,7 @@ export class TelegramDaemonController implements BuiltInDaemonController {
 	#currentConfigurationMatches(tokenFingerprintValue: string, chatId: string): boolean {
 		const current = getNotificationConfig(this.settings);
 		return (
-			isTelegramConfigured(current) &&
+			isTelegramComplete(current) &&
 			tokenFingerprint(current.botToken) === tokenFingerprintValue &&
 			current.chatId === chatId
 		);

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

@@ -11,7 +11,7 @@ import type { DaemonRuntimeInfo } from "../../daemon/control-types";
 import { resolveGjcRuntimeSpawnInfo } from "../../daemon/runtime";
 import { resizeImageBuffer } from "../../utils/image-resize";
 import { isProcessIncarnation, processIncarnation } from "../broker/process-incarnation";
-import { getNotificationConfig, isTelegramConfigured, tokenFingerprint } from "./config";
+import { getNotificationConfig, isProviderEffectivelyEnabled, isTelegramComplete, tokenFingerprint } from "./config";
 import {
 	parseInThreadConfigCommand,
 	parseRichToggleCommand,
@@ -1565,18 +1565,26 @@ async function reapNotificationLeakArtifact(input: {
 	now: number;
 	graceMs: number;
 }): Promise<NotificationArtifactReapOutcome> {
-	if (path.basename(input.file).startsWith(".gjc-exact-unlink-placeholder-")) return "retained";
-	if (!input.fs.readEndpointFile || !input.fs.exactUnlink) return "unchanged";
-	const endpoint = await input.fs.readEndpointFile(input.file);
-	if (!(await isSingleLinkRegularFile(input.fs, input.file))) return "unchanged";
-	const age = input.now - Number(endpoint.identity.mtimeNs / 1_000_000n);
-	if (age < input.graceMs) return "unchanged";
-	return await reapNotificationArtifactExactly(
-		input.fs,
-		input.file,
-		endpoint.identity,
-		`.gjc-exact-unlink-placeholder-${crypto.randomUUID()}.json`,
-	);
+	const name = path.basename(input.file);
+	if (name.startsWith(".gjc-exact-unlink-placeholder-")) return "retained";
+	if (name.startsWith(".gjc-delete-notification-staging-temp-")) {
+		if (!input.fs.readEndpointFile || !input.fs.exactUnlink) return "unchanged";
+		const endpoint = await input.fs.readEndpointFile(input.file);
+		if (!(await isSingleLinkRegularFile(input.fs, input.file))) return "unchanged";
+		const age = input.now - Number(endpoint.identity.mtimeNs / 1_000_000n);
+		if (age < input.graceMs) return "unchanged";
+		return await reapNotificationArtifactExactly(
+			input.fs,
+			input.file,
+			endpoint.identity,
+			`.gjc-exact-unlink-placeholder-${crypto.randomUUID()}.json`,
+		);
+	}
+	if (!input.fs.stat) return "unchanged";
+	const stat = await input.fs.stat(input.file);
+	if (Number.isFinite(stat.mtimeMs) && input.now - stat.mtimeMs < input.graceMs) return "unchanged";
+	await input.fs.unlink(input.file);
+	return "removed";
 }
 
 /**
@@ -3404,7 +3412,7 @@ async function ensureTelegramDaemonRunningDetailedOnce(
 	deps: TelegramDaemonDeps = {},
 ): Promise<EnsureTelegramDaemonDetailedResult> {
 	const cfg = getNotificationConfig(input.settings);
-	if (!isTelegramConfigured(cfg)) return "disabled";
+	if (!isProviderEffectivelyEnabled(cfg, "telegram") || !isTelegramComplete(cfg)) return "disabled";
 	const root = notificationRootForCwd(input.cwd);
 	const fp = tokenFingerprint(cfg.botToken);
 	// A live v0.10 parent has no stable process authority on Windows. Never turn an
@@ -3664,7 +3672,7 @@ export async function ensureTelegramDaemonRunningDetailed(
 	if (input.registerRoot === false || (result !== "attached" && result !== "spawned")) return result;
 
 	const cfg = getNotificationConfig(input.settings);
-	if (!isTelegramConfigured(cfg)) return "disabled";
+	if (!isProviderEffectivelyEnabled(cfg, "telegram") || !isTelegramComplete(cfg)) return "disabled";
 	const ownerIsCurrent = async (): Promise<boolean> => {
 		const snapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: deps.fs });
 		return isCurrentCompatibleOwner({

package/src/sdk/client/discovery.ts

@@ -33,8 +33,10 @@ export class SdkDiscoveryError extends Error {
 	}
 }
 
-function endpointDirectory(repo: string): string {
-	return path.join(repo, ".gjc", "state", "sdk");
+export type SdkSessionEndpointScope = "default" | "chat";
+
+function endpointDirectory(repo: string, scope: SdkSessionEndpointScope = "default"): string {
+	return scope === "chat" ? path.join(repo, ".gjc", "state", "chat", "sdk") : path.join(repo, ".gjc", "state", "sdk");
 }
 
 function parseEndpoint(sessionId: string, file: string, value: unknown): SdkSessionEndpoint {
@@ -101,9 +103,13 @@ export async function listSdkSessionEndpoints(repo: string): Promise<SdkSessionE
 }
 
 /** Resolves one per-session SDK endpoint discovery file. */
-export async function readSdkSessionEndpoint(repo: string, sessionId: string): Promise<SdkSessionEndpoint | null> {
+export async function readSdkSessionEndpoint(
+	repo: string,
+	sessionId: string,
+	scope: SdkSessionEndpointScope = "default",
+): Promise<SdkSessionEndpoint | null> {
 	if (!sessionId || sessionId.includes(path.sep) || sessionId.includes("/")) return null;
-	const file = path.join(endpointDirectory(repo), `${sessionId}.json`);
+	const file = path.join(endpointDirectory(repo, scope), `${sessionId}.json`);
 	try {
 		return parseEndpoint(sessionId, file, JSON.parse(await fs.readFile(file, "utf8")));
 	} catch (error) {