@gajae-code/coding-agent 0.15.6 → 0.16.1

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

@@ -166,8 +166,9 @@ export class DiscordNotificationDaemon {
 		expectedGeneration?: number,
 	) => SessionAttachment | null | Promise<SessionAttachment | null>;
 	readonly #effects: ChatEffectJournal;
-	readonly #activeWork = new Set<Promise<unknown>>();
+	readonly #activeWork = new Map<Promise<unknown>, string | undefined>();
 	readonly #workInvalidators = new Set<() => Promise<void>>();
+	readonly #sessionInvalidators = new Map<string, Set<() => Promise<void>>>();
 	readonly #inflightInbound = new Set<string>();
 	#started = false;
 	#lifecycleGeneration = 0;
@@ -264,7 +265,8 @@ export class DiscordNotificationDaemon {
 				await this.options.provider.start(
 					async event => {
 						if (lifecycleGeneration !== this.#lifecycleGeneration || !this.#started) return;
-						await this.#track(this.handleInbound(event));
+						const record = await this.#byThread(event.guildId, event.parentId, event.threadId);
+						await this.#track(this.handleInbound(event), record?.sessionId);
 					},
 					() => {},
 				);
@@ -375,6 +377,9 @@ export class DiscordNotificationDaemon {
 		this.#workGeneration += 1;
 		await Promise.allSettled([...this.#workInvalidators].map(invalidate => invalidate()));
 	}
+	async #invalidateSessionWork(sessionId: string): Promise<void> {
+		await Promise.allSettled([...(this.#sessionInvalidators.get(sessionId) ?? [])].map(invalidate => invalidate()));
+	}
 
 	async #drainActiveWork(deadline: number): Promise<void> {
 		while (this.#activeWork.size > 0) {
@@ -385,7 +390,7 @@ export class DiscordNotificationDaemon {
 				return;
 			}
 			const settled = await Promise.race([
-				Promise.allSettled([...this.#activeWork]).then(() => true),
+				Promise.allSettled([...this.#activeWork.keys()]).then(() => true),
 				Bun.sleep(remaining).then(() => false),
 			]);
 			if (!settled) {
@@ -395,6 +400,17 @@ export class DiscordNotificationDaemon {
 			}
 		}
 	}
+	async #drainSessionWork(sessionId: string, deadline: number): Promise<void> {
+		while (true) {
+			const work = [...this.#activeWork.entries()]
+				.filter(([, activeSessionId]) => activeSessionId === sessionId)
+				.map(([promise]) => promise);
+			if (work.length === 0) return;
+			const remaining = deadline - this.#now();
+			if (remaining <= 0) return;
+			await Promise.race([Promise.allSettled(work), Bun.sleep(remaining)]);
+		}
+	}
 
 	#recordProviderLifecycleError(error: unknown): void {
 		this.#providerLifecycleError = error;
@@ -422,7 +438,7 @@ export class DiscordNotificationDaemon {
 	 * legitimate create into a spurious teardown rejection.
 	 */
 	async notify(input: DiscordNotificationInput): Promise<DiscordConversation> {
-		return await this.#track(this.#notify(input));
+		return await this.#track(this.#notify(input), input.sessionId);
 	}
 	async #notify(input: DiscordNotificationInput): Promise<DiscordConversation> {
 		await this.#requireLiveBinding(input.sessionId, input.endpointGeneration, input.attachmentAuthorityId);
@@ -457,7 +473,7 @@ export class DiscordNotificationDaemon {
 
 	/** Posts a safe command outcome to the active mapped conversation. */
 	async postCommandResult(sessionId: string, content: string): Promise<boolean> {
-		return await this.#track(this.#postCommandResult(sessionId, content));
+		return await this.#track(this.#postCommandResult(sessionId, content), sessionId);
 	}
 	async #postCommandResult(sessionId: string, content: string): Promise<boolean> {
 		const record = await this.#bySession(sessionId);
@@ -471,13 +487,20 @@ export class DiscordNotificationDaemon {
 		if (closing) await this.#driveClose(closing);
 	}
 
-	async recoverCleanup(sessionId: string, endpointGeneration: number): Promise<void> {
+	async recoverCleanup(sessionId: string, endpointGeneration: number, authorityId?: string): Promise<boolean> {
 		const record = await this.#bySession(sessionId);
-		if (record?.endpointGeneration !== endpointGeneration || !closingIntent(record)) return;
+		if (record?.endpointGeneration !== endpointGeneration) return true;
+		if (record?.state === "closed" || record?.state === "archived" || record?.state === "resuming") return true;
+		if (!closingIntent(record) && record?.state === "active" && record.attachmentAuthorityId === authorityId)
+			return true;
+		if (!closingIntent(record)) return false;
 		await this.#driveClose(record);
+		return true;
 	}
 
 	async retireAttachment(sessionId: string, endpointGeneration: number): Promise<void> {
+		await this.#invalidateSessionWork(sessionId);
+		await this.#drainSessionWork(sessionId, this.#now() + 5_000);
 		const intentKey = this.#intentKey(sessionId);
 		const now = this.#now();
 		await this.#store.transact(intentKey, current => {
@@ -548,7 +571,7 @@ export class DiscordNotificationDaemon {
 		endpointGeneration: number,
 		attachmentAuthorityId?: string,
 	): Promise<DiscordConversation | undefined> {
-		return await this.#track(this.#resumeAdmission(sessionId, endpointGeneration, attachmentAuthorityId));
+		return await this.#track(this.#resumeAdmission(sessionId, endpointGeneration, attachmentAuthorityId), sessionId);
 	}
 	async #resumeAdmission(
 		sessionId: string,
@@ -665,8 +688,8 @@ export class DiscordNotificationDaemon {
 		}
 	}
 
-	#track<T>(work: Promise<T>): Promise<T> {
-		this.#activeWork.add(work);
+	#track<T>(work: Promise<T>, sessionId?: string): Promise<T> {
+		this.#activeWork.set(work, sessionId);
 		return work.finally(() => this.#activeWork.delete(work));
 	}
 
@@ -1871,6 +1894,11 @@ export class DiscordNotificationDaemon {
 	#intentKey(sessionId: string): string {
 		return `${this.options.provider.applicationId}:${this.options.guildId}:${this.options.parentChannelId}:creating:${sessionId}`;
 	}
+	#removeSessionInvalidator(sessionId: string, set: Set<() => Promise<void>>, invalidate: () => Promise<void>): void {
+		set.delete(invalidate);
+		if (set.size === 0 && this.#sessionInvalidators.get(sessionId) === set)
+			this.#sessionInvalidators.delete(sessionId);
+	}
 	async #withCreateIntentLease<T>(intent: DiscordConversation, work: () => Promise<T>): Promise<T> {
 		let lost = false;
 		let renewal: Promise<boolean> | undefined;
@@ -1886,6 +1914,9 @@ export class DiscordNotificationDaemon {
 			await abandonCurrent();
 		};
 		this.#workInvalidators.add(invalidate);
+		const sessionInvalidators = this.#sessionInvalidators.get(intent.sessionId!) ?? new Set<() => Promise<void>>();
+		sessionInvalidators.add(invalidate);
+		this.#sessionInvalidators.set(intent.sessionId!, sessionInvalidators);
 		const renew = async (): Promise<boolean> => {
 			if (lost || workGeneration !== this.#workGeneration) {
 				await invalidate();
@@ -1953,6 +1984,7 @@ export class DiscordNotificationDaemon {
 		} finally {
 			clearInterval(timer);
 			this.#workInvalidators.delete(invalidate);
+			this.#removeSessionInvalidator(intent.sessionId!, sessionInvalidators, invalidate);
 		}
 	}
 	async #clearPending(record: DiscordConversation, actionId: string, actionNonce: string): Promise<void> {
@@ -2076,6 +2108,12 @@ export class DiscordNotificationDaemon {
 			);
 		};
 		this.#workInvalidators.add(invalidate);
+		let sessionInvalidators: Set<() => Promise<void>> | undefined;
+		if (sessionId !== undefined) {
+			sessionInvalidators = this.#sessionInvalidators.get(sessionId) ?? new Set<() => Promise<void>>();
+			sessionInvalidators.add(invalidate);
+			this.#sessionInvalidators.set(sessionId, sessionInvalidators);
+		}
 		const renewLease = async (): Promise<boolean> => {
 			if (renewalLost || workGeneration !== this.#workGeneration) {
 				renewalLost = true;
@@ -2136,6 +2174,8 @@ export class DiscordNotificationDaemon {
 		} finally {
 			clearInterval(timer);
 			this.#workInvalidators.delete(invalidate);
+			if (sessionId !== undefined && sessionInvalidators !== undefined)
+				this.#removeSessionInvalidator(sessionId, sessionInvalidators, invalidate);
 		}
 	}
 

package/src/sdk/bus/index.ts

@@ -90,14 +90,17 @@ import { acpFinalTextFromMessage } from "../acp/final-text";
 import { ensureBroker } from "../broker/ensure";
 import { publishSessionHostRuntimeEvidence, type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { processIncarnation } from "../broker/process-incarnation";
-import { SessionIndex } from "../broker/session-index";
+import { resolveSessionLocator, SessionIndex } from "../broker/session-index";
 import {
 	CAP_GATED_FRAME_KINDS,
 	createSdkSurfaceFactory,
+	masterAttestationForEffectiveHost,
+	reattestMasterSessionIdentity,
 	type SessionSdkHost,
 	SessionSdkSessionRuntime,
 	shouldHostSdk,
 	TOOL_ACTIVITY_CAPABILITY,
+	verifyMasterCapabilityFrame,
 } from "../host";
 import { type AbortScope, type ControlSurface, dispatchControl, TypedControlError } from "../host/control";
 import { BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD } from "../host/control/runtime-gate";
@@ -371,6 +374,8 @@ export type LifecycleErrorReason =
 	| "spawn_failed"
 	| "discovery_timeout"
 	| "readiness_timeout"
+	| "worktree_preparation_timeout"
+	| "dependency_preparation_timeout"
 	| "close_refused"
 	| "not_found"
 	| "terminal_uncertain"
@@ -1220,6 +1225,8 @@ interface SessionRuntime {
 	disposeGateTerminalController: () => void;
 	disposeAckRecoveryParticipant: () => void;
 	disposeGateEmitterListener: () => void;
+	/** Deregisters this session's job-fold listener (`bash_folded`). */
+	disposeFoldListener: () => void;
 	/** Aborts and fences side turns while notification delivery is disabled. */
 	disableEphemeralTurns: () => void;
 	waitForGateResolutionQuiescence: () => Promise<void>;
@@ -2381,6 +2388,7 @@ function sdkQuerySurface(
 	steerStatusLookup: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown = () => ({
 		status: "unknown",
 	}),
+	getRuntimeHost: () => SessionSdkHost | undefined = () => undefined,
 ): SessionSurface {
 	return createSdkSurfaceFactory({
 		ctx,
@@ -2393,6 +2401,7 @@ function sdkQuerySurface(
 		turnResultLookup,
 		steerStatusLookup,
 		hostTools: () => getInstalledDefinitions("host_tools") !== undefined,
+		getRuntimeHost,
 	}).query;
 }
 
@@ -3519,7 +3528,7 @@ function sdkControlSurface(
 		setQueueMode: (kind, mode) => {
 			if (!bindings.has("setQueueMode"))
 				return unavailable(`queue.${kind}_mode.set`, "no session queue-mode seam is installed")();
-			if (!ctx.setQueueMode(kind as "steering" | "follow_up" | "interrupt", mode))
+			if (!ctx.setQueueMode(kind as "steering" | "follow_up" | "tool_interrupt", mode))
 				throw Object.assign(new Error("Invalid queue mode."), { code: "invalid_input" });
 			return { changed: true };
 		},
@@ -4043,6 +4052,12 @@ export function createNotificationsExtension(
 		controller?: NotificationSessionController;
 		/** Whether this host mode can own the root SDK endpoint. Default: true. */
 		sdkHostModeSupported?: boolean;
+		/** In-memory master capability for private broker verification only. */
+		masterCapability?: string;
+		/** Opaque direct-role epoch this effective host may adopt. */
+		masterAttestationEpoch?: string;
+		/** Stable master lineage identity retained across session switches/branches. */
+		masterOwnerSessionId?: string;
 		onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
 		runBtwTurn?: (question: string, signal: AbortSignal) => Promise<{ replyText: string }>;
 		/** Observes settlement of optional session-branch startup after reconciliation completes. */
@@ -4103,6 +4118,7 @@ export function createNotificationsExtension(
 		  }
 		| undefined;
 	let extensionShuttingDown = false;
+	const consumedMasterNonces = new Map<string, number>();
 
 	async function ensureTelegramOwner(settings: Settings): Promise<"ready" | "blocked_identity"> {
 		if (!telegramTopicsEnabled()) return "blocked_identity";
@@ -4368,8 +4384,14 @@ export function createNotificationsExtension(
 			rt.workflowGate?.setRuntimeTurnProvider?.(null);
 		} catch {}
 		try {
+			const attachedClients = rt.server.clientCount();
 			const delivered = await pushTerminalSessionFrame(rt, { type: "session_closed", sessionId: id });
-			if (!delivered) logger.warn("notifications: session_closed socket delivery was not acknowledged");
+			if (!delivered) {
+				const fields = { sessionId: id, endpointScope: rt.endpointScope, attachedClients };
+				if (attachedClients > 0)
+					logger.warn("notifications: session_closed socket delivery was not acknowledged", fields);
+				else logger.debug("notifications: session_closed had no attached client to acknowledge", fields);
+			}
 		} catch (e) {
 			logger.warn(`notifications: session_closed failed: ${String(e)}`);
 		}
@@ -4380,6 +4402,9 @@ export function createNotificationsExtension(
 		try {
 			rt.disposeGateEmitterListener();
 		} catch {}
+		try {
+			rt.disposeFoldListener();
+		} catch {}
 		rt.gatePresentations?.dispose();
 		try {
 			rt.disposeGateTerminalController();
@@ -4489,12 +4514,14 @@ export function createNotificationsExtension(
 
 	async function startSession(ctx: ExtensionContext): Promise<SessionStartResult> {
 		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).genericSessionEnabled;
 		const sdkEnabledForSession =
 			(options.sdkHostModeSupported ?? true) && shouldHostSdk(settings, isNotificationEligibleContext(ctx));
 		const lifecycleRequired = lifecycleStartupCapability !== undefined;
+		const lifecycleRequestId = lifecycleRequired
+			? safeLifecycleRequestId(lifecycleStartupCapability.lifecycleRequestId)
+			: safeLifecycleRequestId(process.env.GJC_LIFECYCLE_REQUEST_ID);
 		/** The broker-issued readiness intent for this exact lifecycle-managed session. */
 		const lifecycleReadiness = lifecycleStartupCapability?.readiness ?? "immediate";
 		const failLifecycleStartup = (
@@ -5270,7 +5297,6 @@ export function createNotificationsExtension(
 					submission.reconciliationKind,
 					correlation,
 					winner,
-					undefined,
 					extra?.error,
 					extra?.finalText,
 				);
@@ -5442,6 +5468,7 @@ export function createNotificationsExtension(
 				settings,
 				selector => kindReconciliation.lookupResult(selector.kind, selector),
 				selector => kindReconciliation.lookupSteer(selector),
+				() => host,
 			),
 			id,
 			revisions,
@@ -6588,6 +6615,7 @@ export function createNotificationsExtension(
 		}
 
 		sdkRuntime = new SessionSdkSessionRuntime({
+			masterOwnerSessionId: options.masterOwnerSessionId,
 			transport: {
 				sessionId: id,
 				stateRoot,
@@ -6607,6 +6635,13 @@ export function createNotificationsExtension(
 			...(activationGate ? { activationGate } : {}),
 			...(settings ? { settings } : {}),
 			...(configOverrides ? { configOverrides } : {}),
+			masterCapabilityVerify: frame =>
+				verifyMasterCapabilityFrame({
+					frame,
+					expectedCapability: options.masterCapability,
+					expectedEpoch: options.masterAttestationEpoch,
+					replay: consumedMasterNonces,
+				}),
 			connectionCapabilities: connectionId => hostCapCache.get(connectionId),
 			installProviderDefinitions,
 			onProviderDefinitionsRemoved: removeProviderDefinitions,
@@ -6965,6 +7000,7 @@ export function createNotificationsExtension(
 				]);
 			},
 			disposeGateEmitterListener: () => {},
+			disposeFoldListener: () => {},
 			trackGateResolution,
 			waitForGateResolutionQuiescence: async () => {
 				await Promise.allSettled(inFlightGateResolutions);
@@ -7751,6 +7787,8 @@ export function createNotificationsExtension(
 			}
 			const agentDir = lifecycleAgentDir ?? settings?.getAgentDir?.();
 			if (lifecycleRequired && !agentDir) throw new Error("Lifecycle SDK host requires an agent directory.");
+			if (lifecycleRequired && !lifecycleRequestId)
+				throw new Error("Lifecycle SDK host requires a capability-bound request identity.");
 
 			if (agentDir) {
 				try {
@@ -7758,13 +7796,36 @@ export function createNotificationsExtension(
 					throwIfLifecycleStopped();
 					const index = await new SessionIndex(agentDir).open();
 					throwIfLifecycleStopped();
-					const locator = { repo: path.resolve(ctx.cwd), stateRoot: endpointStateRoot };
-					const endpointMtimeMs = fs.statSync(path.join(endpointStateRoot, "sdk", `${id}.json`)).mtimeMs;
+					const locator = await resolveSessionLocator(ctx.cwd, endpointStateRoot);
+					const endpointPath = path.join(endpointStateRoot, "sdk", `${id}.json`);
+					const endpointMtimeMs = fs.statSync(endpointPath).mtimeMs;
+					const endpointIdentity = fs.statSync(endpointPath, { bigint: true });
+					const endpointFileId = `${endpointIdentity.dev}:${endpointIdentity.ino}`;
 					const hostProcessIncarnation = processIncarnation(process.pid);
+					const direct = await reattestMasterSessionIdentity({
+						index,
+						locator,
+						masterCapability: options.masterCapability,
+						attestationEpoch: options.masterAttestationEpoch,
+						ownerSessionId: options.masterOwnerSessionId,
+						sessionId: id,
+						pid: process.pid,
+						processIncarnation: hostProcessIncarnation,
+					});
+					throwIfLifecycleStopped();
 					await host.registerWithBroker({
 						// The endpoint is written before registration. Its exact mtime
 						// binds this index generation to that discovery record.
 						register: async input => {
+							const masterRole = masterAttestationForEffectiveHost({
+								masterCapability: options.masterCapability,
+								attestationEpoch: options.masterAttestationEpoch,
+								ownerSessionId: options.masterOwnerSessionId,
+								sessionId: input.sessionId,
+								pid: process.pid,
+								processIncarnation: hostProcessIncarnation,
+								direct,
+							});
 							await index.append({
 								type: "host_registered",
 								...input,
@@ -7776,6 +7837,8 @@ export function createNotificationsExtension(
 								// teardown identity provable after that workspace is gone.
 								...(hostProcessIncarnation ? { processIncarnation: hostProcessIncarnation } : {}),
 								endpointMtimeMs,
+								endpointFileId,
+								...(masterRole ? { masterRole } : {}),
 								...(lifecycleRequestId ? { lifecycleRequestId } : {}),
 							});
 						},
@@ -7962,6 +8025,20 @@ export function createNotificationsExtension(
 			};
 			activeRuntime.disposeGateEmitterListener = registerWorkflowGateEmitterListener(id, attachWorkflowGate);
 			if (ctx.workflowGate) attachWorkflowGate(ctx.workflowGate);
+			// Every fold (steer, chord, auto-background timer, `bash.background`)
+			// publishes one replayable `bash_folded` frame. `runtime.jobs.list`
+			// `foldReason` remains the source of truth clients reconcile against after
+			// a replay, since a replayed frame may describe a job that has since ended.
+			activeRuntime.disposeFoldListener =
+				ctx.onJobFold?.(event => {
+					emitSessionEvent(activeRuntime, {
+						type: "bash_folded",
+						sessionId: id,
+						jobId: event.jobId,
+						generation: event.generation,
+						reason: event.reason,
+					});
+				}) ?? (() => {});
 			finishStartup({ status: "started", runtime: initializedRuntime });
 			return { status: "started", runtime: initializedRuntime };
 		} catch (e) {