@gajae-code/coding-agent 0.12.6 → 0.12.8

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

@@ -11,10 +11,11 @@ import {
 } from "./chat-daemon-control";
 import { type ChatDaemonRuntimeConfig, ChatDaemonRuntime as DefaultChatDaemonRuntime } from "./chat-daemon-runtime";
 import {
-	isDiscordConfigured,
-	isSlackConfigured,
+	isDiscordComplete,
+	isSlackComplete,
 	loadNotificationConfigFile,
 	notificationConfigFromFile,
+	resolveNotificationProvider,
 } from "./config";
 
 export interface ChatDaemonRuntimeHandle {
@@ -60,7 +61,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 	const config = notificationConfigFromFile(loaded.value);
 	if (!config.enabled) return undefined;
 	if (kind === "discord") {
-		if (!isDiscordConfigured(config)) {
+		const resolution = resolveNotificationProvider(config, "discord");
+		if (!resolution.desiredEnabled) return undefined;
+		if (resolution.quarantined) throw new Error("Discord notification configuration needs repair");
+		if (!resolution.configured || !isDiscordComplete(config)) {
 			throw new Error("Discord notifications are enabled but configuration is incomplete");
 		}
 		const discord = config.discord;
@@ -78,7 +82,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 			presentation: { redact: config.redact, verbosity: config.verbosity },
 		};
 	}
-	if (!isSlackConfigured(config)) {
+	const resolution = resolveNotificationProvider(config, "slack");
+	if (!resolution.desiredEnabled) return undefined;
+	if (resolution.quarantined) throw new Error("Slack notification configuration needs repair");
+	if (!resolution.configured || !isSlackComplete(config)) {
 		throw new Error("Slack notifications are enabled but configuration is incomplete");
 	}
 	const slack = config.slack;
@@ -149,7 +156,7 @@ export async function runChatDaemonInternal(
 
 	let incarnation: string | undefined;
 	let runtime: ChatDaemonRuntimeHandle | undefined;
-	let interval: ReturnType<typeof setInterval> | undefined;
+	let interval: NodeJS.Timeout | number | undefined;
 	let stopping = false;
 	let terminalError: unknown;
 	let runtimeStop: Promise<void> | undefined;

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

@@ -16,7 +16,7 @@ import type {
 } from "../../daemon/control-types";
 import { resolveGjcRuntimeSpawnInfo } from "../../daemon/runtime";
 import { isProcessIncarnation, processIncarnation } from "../broker/process-incarnation";
-import { getNotificationConfig, isDiscordConfigured, isSlackConfigured } from "./config";
+import { getNotificationConfig, isDiscordComplete, isProviderEffectivelyEnabled, isSlackComplete } from "./config";
 
 export type ChatDaemonKind = "discord" | "slack";
 export type ChatDaemonAction = "stop" | "reload";
@@ -40,13 +40,20 @@ export type ChatDaemonAction = "stop" | "reload";
  * daemon transports. Generation 16 applies Telegram sound-policy configuration
  * through shared notification parsing. Generation 17 bound managed-session
  * replacement to exact native filesystem authority; generation 18 retired that
- * binding, generation 19 bound exact cleanup to parent/link-count authority,
- * generation 20 refreshed retained cleanup semantics, and generation 21 hardens
- * exact Bash process-tree ownership shared by chat daemon cleanup.
+ * binding, and generation 19 binds exact cleanup to parent/link-count authority
+ * while also adding durable provider-intent admission without changing lifecycle
+ * behavior. Generation 20 discovers isolated chat-only session endpoints when
+ * Telegram identity ownership is blocked. Discord generation 21 applies rustfmt
+ * and clippy-equivalent cleanup to the pi-shell process-tree authority (#3682).
+ * Discord generation 22 / slack generation 21 refreshes retained cleanup
+ * semantics; discord generation 23 / slack generation 22 hardens exact Bash
+ * process-tree ownership shared by chat daemon cleanup.
+ * Discord generation 24 / slack generation 23 apply provider-completeness and
+ * effective-enable admission to chat daemon lifecycle controls.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 21,
-	slack: 21,
+	discord: 24,
+	slack: 23,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {
@@ -273,7 +280,7 @@ export function chatDaemonPaths(
 function identityFor(settings: Settings, kind: ChatDaemonKind): string | undefined {
 	const cfg = getNotificationConfig(settings);
 	if (kind === "discord") {
-		if (!isDiscordConfigured(cfg)) return undefined;
+		if (!isDiscordComplete(cfg)) return undefined;
 		return fingerprint([
 			cfg.discord.botToken,
 			cfg.discord.applicationId,
@@ -283,7 +290,7 @@ function identityFor(settings: Settings, kind: ChatDaemonKind): string | undefin
 			cfg.verbosity,
 		]);
 	}
-	if (!isSlackConfigured(cfg)) return undefined;
+	if (!isSlackComplete(cfg)) return undefined;
 	return fingerprint([
 		cfg.slack.botToken,
 		cfg.slack.appToken,
@@ -428,6 +435,9 @@ export class ChatDaemonController implements BuiltInDaemonController {
 	private identity(): string | undefined {
 		return identityFor(this.settings, this.kind);
 	}
+	private effectivelyEnabled(): boolean {
+		return isProviderEffectivelyEnabled(getNotificationConfig(this.settings), this.kind);
+	}
 	private alive(pid: number): boolean {
 		return (this.deps.pidAlive ?? defaultPidAlive)(pid);
 	}
@@ -455,6 +465,7 @@ export class ChatDaemonController implements BuiltInDaemonController {
 		return await this.operate("reload", opts);
 	}
 	async ensure(): Promise<EnsureChatDaemonResult> {
+		if (!this.effectivelyEnabled()) return "disabled";
 		const identity = this.identity();
 		if (!identity) return "disabled";
 		const existing = await readChatDaemonState(this.settings.getAgentDir(), this.kind);
@@ -487,6 +498,9 @@ export class ChatDaemonController implements BuiltInDaemonController {
 		const warnings = before.runtime.warning ? [before.runtime.warning] : [];
 		if (!before.configured)
 			return this.result(action, false, `${this.kind} notifications are not configured`, before, before, warnings);
+		if (action === "reload" && !this.effectivelyEnabled()) {
+			return this.result(action, false, `${this.kind} notifications are not enabled`, before, before, warnings);
+		}
 		const state = await readChatDaemonState(this.settings.getAgentDir(), this.kind);
 		const classification = this.classify(state, this.identity());
 		if (classification === "newer")
@@ -522,6 +536,8 @@ export class ChatDaemonController implements BuiltInDaemonController {
 			}
 			if (opts.spawnIfStopped === false)
 				return this.result(action, true, `no running ${this.kind} daemon to reload`, before, before, warnings);
+			if (!this.effectivelyEnabled())
+				return this.result(action, false, `${this.kind} notifications are not enabled`, before, before, warnings);
 			const spawned = await this.spawn();
 			return this.result(
 				action,
@@ -575,6 +591,15 @@ export class ChatDaemonController implements BuiltInDaemonController {
 		await clearChatDaemonControlRequest(this.settings.getAgentDir(), this.kind, requestId);
 		if (action === "stop")
 			return this.result(action, true, `stopped ${this.kind} daemon`, before, await this.status(), warnings);
+		if (!this.effectivelyEnabled())
+			return this.result(
+				action,
+				false,
+				`${this.kind} notifications are not enabled`,
+				before,
+				await this.status(),
+				warnings,
+			);
 		const spawned = await this.spawn();
 		return this.result(
 			action,
@@ -752,6 +777,7 @@ export class ChatDaemonController implements BuiltInDaemonController {
 		return this.deps.sleep ? this.deps.sleep(ms) : new Promise(resolve => setTimeout(resolve, ms));
 	}
 	private async spawn(): Promise<boolean> {
+		if (!this.effectivelyEnabled()) return false;
 		const identity = this.identity();
 		if (!identity) return false;
 		const paths = chatDaemonPaths(this.settings.getAgentDir(), this.kind);
@@ -768,6 +794,7 @@ export class ChatDaemonController implements BuiltInDaemonController {
 			agentDir: this.settings.getAgentDir(),
 			execPath: this.deps.execPath,
 		});
+		if (!this.effectivelyEnabled() || this.identity() !== identity) return false;
 		(this.deps.spawn ?? ((command, args, opts) => childProcessSpawn(command, args, opts)))(command, args, {
 			detached: true,
 			stdio: "ignore",

package/src/sdk/bus/chat-daemon-runtime.ts

@@ -1,4 +1,6 @@
 import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { type IndexedSession, SessionIndex } from "../broker/session-index";
 import { SdkClient, SdkClientError } from "../client/client";
 import { readSdkBrokerDiscovery, readSdkSessionEndpoint, type SdkSessionEndpoint } from "../client/discovery";
@@ -275,8 +277,20 @@ export class ChatDaemonRuntime {
 	}
 
 	private async attach(indexed: IndexedSession): Promise<void> {
-		const endpoint = await readSdkSessionEndpoint(indexed.locator.repo, indexed.sessionId);
-		if (!endpoint) return;
+		const repo = path.resolve(indexed.locator.repo);
+		const defaultStateRoot = path.join(repo, ".gjc", "state");
+		const indexedStateRoot = path.resolve(indexed.locator.stateRoot);
+		const scope =
+			indexedStateRoot === defaultStateRoot
+				? "default"
+				: indexedStateRoot === path.join(defaultStateRoot, "chat")
+					? "chat"
+					: undefined;
+		if (!scope || indexed.endpointMtimeMs === undefined) return;
+		const endpoint = await readSdkSessionEndpoint(repo, indexed.sessionId, scope);
+		if (!endpoint || endpoint.stale) return;
+		const endpointStat = await fs.stat(endpoint.path).catch(() => undefined);
+		if (!endpointStat || endpointStat.mtimeMs !== indexed.endpointMtimeMs) return;
 		const existing = this.#sessions.get(indexed.sessionId);
 		if (
 			existing &&