@gajae-code/coding-agent 0.12.7 → 0.12.8

package/src/sdk/broker/broker.ts

@@ -12,6 +12,7 @@ import {
 import {
 	BROKER_HEARTBEAT_TTL_MS,
 	type BrokerDiscovery,
+	type BrokerPublicationObservation,
 	brokerDiscoveryPath,
 	brokerProcessIncarnation,
 	heartbeatBrokerDiscoveryRetained,
@@ -396,6 +397,14 @@ type BrokerLockSnapshot = {
 
 const BROKER_PUBLICATION_CADENCE_MS = 5_000;
 const BROKER_PUBLICATION_GRACE_MS = 15_000;
+// A broker that cannot observe its own publication is not provably the root, but
+// ambiguity is also not proof of replacement, so it must not be treated as a
+// `lost-root` immediately. It must still be bounded: an indefinitely ambiguous
+// broker stops heartbeating, so peers discover it as stale and spawn replacements
+// while it keeps its port and memory forever. Ambiguity therefore accrues against
+// its own deadline, generous enough to absorb transient filesystem faults and far
+// longer than the loss grace.
+const BROKER_AMBIGUITY_GRACE_MS = 120_000;
 const BROKER_SETTLEMENT_MS = 2_000;
 type BrokerPublicationState =
 	| "healthy-owned"
@@ -406,6 +415,8 @@ type BrokerPublicationState =
 type BrokerStopMode = "owned-root" | "lost-root";
 
 const terminalPersistenceHooksForTest = new WeakMap<Broker, () => void>();
+const ambiguityGraceOverridesForTest = new WeakMap<Broker, number>();
+const publicationObservationOverridesForTest = new WeakMap<Broker, BrokerPublicationObservation>();
 
 export class Broker {
 	readonly settings: ResolvedBrokerSettings;
@@ -419,6 +430,7 @@ export class Broker {
 	#publication: RetainedBrokerDiscovery | null = null;
 	#publicationState: BrokerPublicationState = "healthy-owned";
 	#lossAt: bigint | null = null;
+	#ambiguousAt: bigint | null = null;
 	#stopping = false;
 	#transport: BrokerTransport | null = null;
 	#heartbeatTimer: NodeJS.Timeout | null = null;
@@ -565,6 +577,7 @@ export class Broker {
 		this.#stopping = false;
 		this.#publicationState = "healthy-owned";
 		this.#lossAt = null;
+		this.#ambiguousAt = null;
 		await Promise.all([this.ledger.assertSupportedStateVersions(), readBrokerDiscovery(this.settings.agentDir)]);
 		await fs.mkdir(path.dirname(this.#lock), { recursive: true, mode: 0o700 });
 		for (;;) {
@@ -648,16 +661,35 @@ export class Broker {
 	#fence(kind: "suspect-unpublished" | "observation-ambiguous" | "heartbeat-ambiguous"): void {
 		if (this.#publicationState === "stopping") return;
 		this.#publicationState = kind;
-		if (kind === "suspect-unpublished") this.#lossAt ??= process.hrtime.bigint();
-		else this.#lossAt = null;
+		if (kind === "suspect-unpublished") {
+			this.#lossAt ??= process.hrtime.bigint();
+			this.#ambiguousAt = null;
+		} else {
+			this.#lossAt = null;
+			this.#ambiguousAt ??= process.hrtime.bigint();
+		}
+	}
+	/**
+	 * Whether this broker has been unable to confirm it is the published root for
+	 * longer than the deadline for its current fence. Replacement is proven quickly
+	 * and ambiguity slowly, but neither may persist indefinitely: a permanently
+	 * fenced broker never heartbeats, so it is unreachable through discovery while
+	 * still holding its port and memory.
+	 */
+	#fencedBeyondDeadline(): boolean {
+		const now = process.hrtime.bigint();
+		if (this.#lossAt !== null && now - this.#lossAt >= BigInt(BROKER_PUBLICATION_GRACE_MS) * 1_000_000n) return true;
+		const ambiguityGraceMs = ambiguityGraceOverridesForTest.get(this) ?? BROKER_AMBIGUITY_GRACE_MS;
+		return this.#ambiguousAt !== null && now - this.#ambiguousAt >= BigInt(ambiguityGraceMs) * 1_000_000n;
 	}
 	async #watchPublication(writeHeartbeat = true): Promise<void> {
 		if (!this.#publication || this.#publicationState === "stopping") return;
 		let observation: ReturnType<RetainedBrokerDiscovery["observe"]>;
 		try {
-			observation = this.#publication.observe();
+			observation = publicationObservationOverridesForTest.get(this) ?? this.#publication.observe();
 		} catch {
 			this.#fence("observation-ambiguous");
+			if (this.#fencedBeyondDeadline()) void this.#complete("lost-root");
 			return;
 		}
 		if (observation === "owned") {
@@ -667,15 +699,12 @@ export class Broker {
 			}
 			this.#publicationState = "healthy-owned";
 			this.#lossAt = null;
+			this.#ambiguousAt = null;
 			if (writeHeartbeat) await this.#writeHeartbeat();
 			return;
 		}
 		this.#fence(observation === "ambiguous" ? "observation-ambiguous" : "suspect-unpublished");
-		if (
-			this.#lossAt !== null &&
-			process.hrtime.bigint() - this.#lossAt >= BigInt(BROKER_PUBLICATION_GRACE_MS) * 1_000_000n
-		)
-			void this.#complete("lost-root");
+		if (this.#fencedBeyondDeadline()) void this.#complete("lost-root");
 	}
 	async #writeHeartbeat(): Promise<void> {
 		if (!this.discovery || !this.#publication || this.#publicationState === "stopping") return;
@@ -691,6 +720,7 @@ export class Broker {
 		}
 		this.#publicationState = "healthy-owned";
 		this.#lossAt = null;
+		this.#ambiguousAt = null;
 		this.discovery = { ...this.discovery, heartbeatAt };
 	}
 	async heartbeat(): Promise<void> {
@@ -938,9 +968,8 @@ export class Broker {
 			});
 			if (isCleanupPending(response)) return response;
 			const persisted = await this.ledger.readTerminal(identity, requestHash);
-			const expectedResponseDigest = createHash("sha256").update(canonicalJson(response)).digest("hex");
 			const persistenceVerified =
-				persisted?.responseDigest === expectedResponseDigest &&
+				persisted !== undefined &&
 				canonicalJson(persisted.response) === canonicalJson(response) &&
 				canonicalJson(persisted.durableEffects) === canonicalJson(outcome.durableEffects) &&
 				canonicalJson(persisted.startupFailure) === canonicalJson(outcome.startupFailure);
@@ -972,3 +1001,18 @@ export function setTerminalPersistenceHookForTest(broker: Broker, hook: (() => v
 	if (hook) terminalPersistenceHooksForTest.set(broker, hook);
 	else terminalPersistenceHooksForTest.delete(broker);
 }
+
+/** Test-only hook for shortening the bounded ambiguity deadline. */
+export function setAmbiguityGraceForTest(broker: Broker, graceMs: number | undefined): void {
+	if (graceMs === undefined) ambiguityGraceOverridesForTest.delete(broker);
+	else ambiguityGraceOverridesForTest.set(broker, graceMs);
+}
+
+/** Test-only hook for forcing the observation the publication watchdog sees. */
+export function setPublicationObservationForTest(
+	broker: Broker,
+	observation: BrokerPublicationObservation | undefined,
+): void {
+	if (observation === undefined) publicationObservationOverridesForTest.delete(broker);
+	else publicationObservationOverridesForTest.set(broker, observation);
+}

package/src/sdk/broker/lifecycle-ledger.ts

@@ -666,7 +666,13 @@ export class LifecycleLedger {
 		return this.#mutate(async () => {
 			const previous = this.#byIdentity.get(identity);
 			if (!previous) throw new Error("Unknown lifecycle identity");
-			const next = { ...previous, ...fields, state, ts: Date.now() };
+			const next = {
+				...previous,
+				...fields,
+				state,
+				ts: Date.now(),
+				...(fields.response !== undefined ? { response: fields.response } : {}),
+			};
 			if (this.#isCleanupPending(next)) {
 				next.unresolvedCleanupResponse = undefined;
 				next.unresolvedCleanupResponseDigest = undefined;
@@ -796,4 +802,31 @@ export class LifecycleLedger {
 	get(identity: string): LifecycleLedgerEntry | undefined {
 		return this.#byIdentity.get(identity);
 	}
+
+	findPendingCleanupByTarget(
+		sessionId: string,
+		cwd: string,
+		transcriptPath: string,
+	): LifecycleLedgerEntry | undefined {
+		const expectedCwd = path.resolve(cwd);
+		const expectedTranscript = path.resolve(transcriptPath);
+		let latest: LifecycleLedgerEntry | undefined;
+		for (const entry of this.#byIdentity.values()) {
+			if (entry.state !== "effect_started" || !this.#isCleanupPending(entry)) continue;
+			const response = entry.response as {
+				error?: { cleanup?: { sessionId?: unknown; cwd?: unknown; transcriptPath?: unknown } };
+			};
+			const cleanup = response.error?.cleanup;
+			if (
+				cleanup?.sessionId !== sessionId ||
+				typeof cleanup.cwd !== "string" ||
+				typeof cleanup.transcriptPath !== "string" ||
+				path.resolve(cleanup.cwd) !== expectedCwd ||
+				path.resolve(cleanup.transcriptPath) !== expectedTranscript
+			)
+				continue;
+			if (!latest || entry.ts > latest.ts) latest = entry;
+		}
+		return latest;
+	}
 }

package/src/sdk/broker/lifecycle.ts

@@ -865,7 +865,7 @@ export async function writeSessionLifecycleReady(root: string, id: string, effec
 	const incarnation = processIncarnation(process.pid);
 	if (!incarnation) throw new Error("Lifecycle child has no readable OS incarnation.");
 	await fs.mkdir(path.join(root, "sdk"), { recursive: true, mode: 0o700 });
-	await fs.writeFile(lifecycleReadyPath(root, id), JSON.stringify({ pid: process.pid, effectMarker, incarnation }), {
+	await fs.writeFile(lifecycleReadyPath(root, id), canonicalJson({ pid: process.pid, effectMarker, incarnation }), {
 		mode: 0o600,
 	});
 }
@@ -1365,15 +1365,6 @@ function lifecycleMetadataReplayFiles(cleanup: CleanupEvidence): LifecycleCleanu
 	return cleanup.lifecycleFiles?.length ? cleanup.lifecycleFiles : undefined;
 }
 
-function absentLifecyclePath(file: string): boolean {
-	try {
-		fsSync.lstatSync(file);
-		return false;
-	} catch (error) {
-		return (error as NodeJS.ErrnoException).code === "ENOENT";
-	}
-}
-
 function isLifecycleCleanupResponse(value: LifecycleFileCapture | BrokerResponse | undefined): value is BrokerResponse {
 	return typeof value === "object" && value !== null && "ok" in value;
 }
@@ -1423,6 +1414,19 @@ function validateLifecycleMetadataReplay(cleanup: CleanupEvidence): BrokerRespon
 			try {
 				current = captureLifecycleFile(candidate, true, true);
 			} catch {
+				if (
+					file.completed &&
+					[file.detachedPath, file.plannedPath].some(
+						bound => bound && path.resolve(candidate) === path.resolve(bound),
+					)
+				) {
+					try {
+						const stat = fsSync.lstatSync(candidate);
+						if (stat.isFile() && !stat.isSymbolicLink() && stat.nlink === 1 && stat.size === 0) continue;
+					} catch (error) {
+						if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+					}
+				}
 				return fail("terminal_uncertain", "Lifecycle metadata candidate could not be safely inspected.");
 			}
 			if (!current) continue;
@@ -1457,7 +1461,7 @@ function validateLifecycleMetadataReplay(cleanup: CleanupEvidence): BrokerRespon
 	if (!markerEntry)
 		return fail("terminal_uncertain", "Lifecycle readiness metadata lacks canonical marker authority.");
 	if (!marker) {
-		if (createHash("sha256").update(canonicalJson(readyMarker)).digest("hex") !== markerEntry.identity.sha256)
+		if (createHash("sha256").update(ready.bytes).digest("hex") !== markerEntry.identity.sha256)
 			return fail(
 				"terminal_uncertain",
 				"Lifecycle readiness metadata is not bound to the completed marker authority.",
@@ -1473,30 +1477,6 @@ function validateLifecycleMetadataReplay(cleanup: CleanupEvidence): BrokerRespon
 	return undefined;
 }
 
-function lifecycleMetadataReplayAbsent(cleanup: CleanupEvidence): boolean {
-	const files = lifecycleMetadataReplayFiles(cleanup);
-	if (!files) return true;
-	const root = path.resolve(cleanup.metadataRoot!);
-	const id = cleanup.sessionId!;
-	const required = new Set<string>([lifecycleMarkerPath(root, id), lifecycleReadyPath(root, id)]);
-	for (const file of files) for (const candidate of lifecycleCleanupCandidates(file)) required.add(candidate);
-	for (const candidate of required) {
-		if (absentLifecyclePath(candidate)) continue;
-		// A completed file's recorded retained quarantine is durable evidence, not a
-		// survivor — accept it only at its receipt-bound path and identity.
-		const owner = files.find(
-			file =>
-				file.completed === true &&
-				file.detachedPath !== undefined &&
-				path.resolve(file.detachedPath) === path.resolve(candidate),
-		);
-		if (!owner) return false;
-		const current = captureLifecycleFile(candidate, true, true);
-		if (!current || !sameLifecycleCleanupIdentity(current.identity, owner.identity)) return false;
-	}
-	return true;
-}
-
 /**
  * Base dev persisted metadata cleanup one file at a time. Accept only its
  * identity-bound marker receipt and translate it into the current replay plan.
@@ -1612,7 +1592,7 @@ function legacyMetadataCleanupPlan(cleanup: CleanupEvidence): CleanupEvidence |
 			return undefined;
 		}
 		if (marker && !sameEffectMarker(marker, readyMarker)) return undefined;
-		if (!marker && createHash("sha256").update(canonicalJson(readyMarker)).digest("hex") !== persistedIdentity.sha256)
+		if (!marker && createHash("sha256").update(ready.capture.bytes).digest("hex") !== persistedIdentity.sha256)
 			return undefined;
 	}
 
@@ -1785,11 +1765,11 @@ async function reconcileLifecycleCleanup(
 					file.detachedPath &&
 					path.resolve(candidate) === path.resolve(file.detachedPath) &&
 					stat.isFile() &&
-					!stat.isSymbolicLink()
-				) {
-					const current = captureLifecycleFile(candidate, true, true);
-					if (current && sameLifecycleCleanupIdentity(current.identity, file.identity)) continue;
-				}
+					!stat.isSymbolicLink() &&
+					stat.nlink === 1 &&
+					stat.size === 0
+				)
+					continue;
 				return fail(
 					"terminal_uncertain",
 					"Lifecycle cleanup receipt marks a target complete while an authorized candidate remains.",
@@ -1892,7 +1872,7 @@ async function reconcileLifecycleCleanup(
 			});
 		}
 		const lifecycleFiles = activeCleanup.lifecycleFiles!.map((candidate, candidateIndex) =>
-			candidateIndex === index ? { ...candidate, completed: true as const } : candidate,
+			candidateIndex === index ? { ...candidate, detachedPath: undefined, completed: true as const } : candidate,
 		);
 		activeCleanup = { ...activeCleanup, lifecycleFiles };
 		await broker.ledger.transition(identity, "effect_started", {
@@ -1900,8 +1880,6 @@ async function reconcileLifecycleCleanup(
 		});
 		lifecycleCleanupHooksForTest.get(broker)?.();
 	}
-	if (!lifecycleMetadataReplayAbsent(activeCleanup))
-		return fail("terminal_uncertain", "Lifecycle metadata replay left an authorized sibling behind.");
 	await syncDirectory(path.join(activeCleanup.metadataRoot!, "sdk"));
 	return completion;
 }
@@ -3463,6 +3441,21 @@ async function executeLifecycleResponse(
 				return (error as NodeJS.ErrnoException).code === "ENOENT";
 			}
 		};
+		try {
+			const currentTranscript = fsSync.lstatSync(cleanupTarget.transcriptPath, { bigint: true });
+			if (
+				currentTranscript.isFile() &&
+				!currentTranscript.isSymbolicLink() &&
+				currentTranscript.dev === cleanupTarget.transcriptIdentity.dev &&
+				currentTranscript.ino === cleanupTarget.transcriptIdentity.ino
+			)
+				cleanupTarget.transcriptIdentity = {
+					...cleanupTarget.transcriptIdentity,
+					nlink: currentTranscript.nlink,
+				};
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		}
 		const transcriptParentIdentity = cleanup?.transcriptParentIdentity ?? validated.transcriptParentIdentity;
 		const durableArtifactsPlan =
 			cleanup?.artifactTree?.plannedPath ?? cleanup?.plannedArtifactsPath ?? cleanupTarget.plannedArtifactsPath;
@@ -3687,11 +3680,17 @@ async function executeLifecycleResponse(
 		const retainedTranscriptReplayHasNoSideAuthority = retainedTranscriptSidePaths.every(
 			candidate => candidate === undefined,
 		);
-		const retainedTranscriptSideAuthorityIsProvenAbsent =
-			retainedTranscriptSidePaths.every(pathIsAbsent) &&
-			(cleanupTarget.detachedTranscriptPath ? true : retainedTranscriptIdentityIsAbsentFromParent());
 		if (cleanup && !retainedTranscriptReplayHasNoSideAuthority) {
-			if (!retainedTranscriptSideAuthorityIsProvenAbsent) return await publishRetainedTranscriptSideAuthority();
+			const successorOrUnknownRemains = [
+				cleanupTarget.retainedTranscriptSuccessorPath,
+				cleanupTarget.retainedTranscriptUnknownPath,
+			].some(candidate => candidate !== undefined && !pathIsAbsent(candidate));
+			if (
+				successorOrUnknownRemains ||
+				!pathIsAbsent(cleanupTarget.retainedTranscriptPlaceholderPath) ||
+				(!cleanupTarget.detachedTranscriptPath && !retainedTranscriptIdentityIsAbsentFromParent())
+			)
+				return await publishRetainedTranscriptSideAuthority();
 			cleanupTarget.retainedTranscriptSuccessorPath = undefined;
 			cleanupTarget.retainedTranscriptPlaceholderPath = undefined;
 			cleanupTarget.retainedTranscriptUnknownPath = undefined;
@@ -3861,8 +3860,6 @@ async function executeLifecycleResponse(
 				preauthorizedCleanup,
 				"Saved session cleanup is pending in artifacts: a planned quarantine alias remains before terminal completion.",
 			);
-		if (deleted.kind === "deleted" && !retainedTranscriptIdentityIsAbsentFromParent())
-			return await publishRetainedTranscriptSideAuthority();
 		const retainedRootArtifactsPlan = durableArtifactsPlan;
 		if (deleted.kind === "cleanup_pending")
 			return fail(

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,11 +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, and generation 19 binds exact cleanup to parent/link-count authority.
+ * 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: 20,
-	slack: 20,
+	discord: 24,
+	slack: 23,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {
@@ -271,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,
@@ -281,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,
@@ -426,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);
 	}
@@ -453,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);
@@ -485,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")
@@ -520,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,
@@ -573,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,
@@ -750,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);
@@ -766,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 &&