@gajae-code/coding-agent 0.12.5 → 0.12.6

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

@@ -39,13 +39,14 @@ export type ChatDaemonAction = "stop" | "reload";
  * applies the current notification configuration directly when starting chat
  * 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 retires that
- * binding (revert of #3489, which stalled POSIX artifact cleanup) while keeping
- * the lifecycle contract moving strictly forward.
+ * 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.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 18,
-	slack: 18,
+	discord: 21,
+	slack: 21,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {
@@ -245,6 +246,9 @@ interface ChatDaemonOwnerLockLease {
 	ino: bigint;
 	size: bigint;
 	mtimeNs: bigint;
+	nlink: bigint;
+	parentDev: bigint;
+	parentIno: bigint;
 	sha256: string;
 }
 
@@ -892,6 +896,7 @@ async function createChatDaemonOwnerLock(
 			if (isAlreadyExists(error)) return undefined;
 			throw error;
 		}
+		await fs.promises.unlink(temporary);
 		return await captureChatDaemonOwnerLockLease(lock);
 	} finally {
 		await fs.promises.unlink(temporary).catch(() => undefined);
@@ -903,14 +908,22 @@ async function captureChatDaemonOwnerLockLease(lock: string): Promise<ChatDaemon
 		const handle = await fs.promises.open(lock, "r");
 		try {
 			const before = await handle.stat({ bigint: true });
+			const parentBefore = await fs.promises.lstat(path.dirname(lock), { bigint: true });
 			if (!before.isFile()) return undefined;
 			const content = await handle.readFile({ encoding: "utf8" });
 			const after = await handle.stat({ bigint: true });
 			const pathname = await fs.promises.lstat(lock, { bigint: true });
+			const parentAfter = await fs.promises.lstat(path.dirname(lock), { bigint: true });
 			if (
 				!after.isFile() ||
 				!pathname.isFile() ||
 				pathname.isSymbolicLink() ||
+				before.nlink !== 1n ||
+				pathname.nlink !== 1n ||
+				!parentBefore.isDirectory() ||
+				parentBefore.isSymbolicLink() ||
+				parentBefore.dev !== parentAfter.dev ||
+				parentBefore.ino !== parentAfter.ino ||
 				before.dev !== after.dev ||
 				before.ino !== after.ino ||
 				before.size !== after.size ||
@@ -927,6 +940,9 @@ async function captureChatDaemonOwnerLockLease(lock: string): Promise<ChatDaemon
 				ino: before.ino,
 				size: before.size,
 				mtimeNs: before.mtimeNs,
+				nlink: before.nlink,
+				parentDev: parentBefore.dev,
+				parentIno: parentBefore.ino,
 				sha256: crypto.createHash("sha256").update(content).digest("hex"),
 			};
 		} finally {
@@ -944,6 +960,9 @@ async function ownsChatDaemonOwnerLock(lock: string, lease: ChatDaemonOwnerLockL
 		current.ino === lease.ino &&
 		current.size === lease.size &&
 		current.mtimeNs === lease.mtimeNs &&
+		current.nlink === lease.nlink &&
+		current.parentDev === lease.parentDev &&
+		current.parentIno === lease.parentIno &&
 		current.content === lease.content
 	);
 }
@@ -952,7 +971,14 @@ async function ownsChatDaemonOwnerLock(lock: string, lease: ChatDaemonOwnerLockL
 function unlinkExactChatDaemonOwnerLock(lock: string, lease: ChatDaemonOwnerLockLease): boolean {
 	try {
 		const removed = native.exactUnlink(lock, {
-			...lease,
+			dev: lease.dev,
+			ino: lease.ino,
+			size: lease.size,
+			mtimeNs: lease.mtimeNs,
+			nlink: lease.nlink,
+			parentDev: lease.parentDev,
+			parentIno: lease.parentIno,
+			sha256: lease.sha256,
 			quarantineName: `.gjc-delete-chat-daemon-lock-${crypto.randomUUID()}`,
 		});
 		if (removed.ok) return true;

package/src/sdk/bus/index.ts

@@ -27,7 +27,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { ThinkingLevel } from "@gajae-code/agent-core";
+import { type RunSettlementProof, ThinkingLevel } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent, Tool } from "@gajae-code/ai";
 import { NotificationServer, nativeBuildInfo } from "@gajae-code/natives";
 import { $credentialEnv, logger, postmortem, VERSION } from "@gajae-code/utils";
@@ -61,7 +61,7 @@ import { registerAskAnswerSource, registerWorkflowGateEmitterListener } from "..
 import { acpFinalTextFromMessage } from "../acp/final-text";
 import { ensureBroker } from "../broker/ensure";
 import { SessionIndex } from "../broker/session-index";
-import { SessionSdkHost, shouldHostSdk } from "../host";
+import { ReverseLeaseError, 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";
@@ -116,6 +116,25 @@ export {
 	runIdentityControlTerminalPath,
 } from "./control-drain-lease";
 
+const PROMPT_SETTLEMENT_DIAGNOSTIC_ENTRY_LIMIT = 8;
+const PROMPT_SETTLEMENT_DIAGNOSTIC_MAX_AGE_MS = 86_400_000;
+
+export function formatPromptSettlementDiagnostic(
+	proof: Extract<RunSettlementProof, { status: "unfenced" }>,
+	now = Date.now(),
+): string {
+	const pending = proof.pending.slice(0, PROMPT_SETTLEMENT_DIAGNOSTIC_ENTRY_LIMIT).map(entry => ({
+		kind: entry.kind,
+		labelHash: crypto.createHash("sha256").update(entry.label).digest("hex").slice(0, 16),
+		ageMs: Math.max(0, Math.min(PROMPT_SETTLEMENT_DIAGNOSTIC_MAX_AGE_MS, now - entry.registeredAt)),
+	}));
+	return JSON.stringify({
+		reason: proof.reason,
+		pending,
+		omitted: Math.max(0, proof.pending.length - pending.length),
+	});
+}
+
 // ===========================================================================
 // Session lifecycle control protocol (TypeScript mirror of the Rust wire
 // contract in `crates/gjc-sdk/src/lifecycle.rs`).
@@ -3239,6 +3258,8 @@ export function createNotificationsExtension(
 				awaitStartup: boolean;
 		  }
 		| undefined;
+	const MAX_SYNTHETIC_SEAM_ADMISSIONS = 64;
+	let syntheticSeamAdmissions = 0;
 	let extensionShuttingDown = false;
 
 	async function ensureTelegramOwner(
@@ -3548,8 +3569,64 @@ export function createNotificationsExtension(
 		const revisions = new RevisionStore(id, Date.now, { storageDir: stateRoot });
 		let host: SessionSdkHost | undefined;
 		let disposeUiAnswerSource: (() => void) | undefined;
-		const installProviderDefinitions = (capability: string, definitions: unknown) => {
+		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,
+		) => {
 			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(
@@ -3587,6 +3664,179 @@ 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.
@@ -3618,11 +3868,17 @@ export function createNotificationsExtension(
 			};
 			if (!canRead) delete bridge.readTextFile;
 			if (!canWrite) delete bridge.writeTextFile;
-			ctx.setSdkClientBridge?.(bridge);
+			fsClientBridge = bridge;
+			refreshSdkClientBridge();
 		};
 		const removeProviderDefinitions = (capability: string) => {
 			if (capability === "permission") ctx.setSdkPermissionProvider?.(undefined);
-			if (capability === "fs") ctx.setSdkClientBridge?.(undefined);
+			if (capability === "fs") fsClientBridge = undefined;
+			if (capability === "terminal") {
+				terminalClientBridge = undefined;
+				terminalPublicationFailedLeaseId = undefined;
+			}
+			if (capability === "fs" || capability === "terminal") refreshSdkClientBridge();
 			if (capability === "ui") {
 				disposeUiAnswerSource?.();
 				disposeUiAnswerSource = undefined;
@@ -3630,6 +3886,12 @@ 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 };
@@ -3990,10 +4252,7 @@ export function createNotificationsExtension(
 			submission.phase = "terminalizing";
 			if (options.fence) {
 				const seam = ctx as typeof ctx & {
-					abortPromptAndWait?: (
-						handle: string,
-						options: { graceMs: number },
-					) => Promise<{ status: "settled" } | { status: "unfenced" }>;
+					abortPromptAndWait?: (handle: string, options: { graceMs: number }) => Promise<RunSettlementProof>;
 				};
 				// Only the handle captured for this correlation may be fenced; a later run
 				// must never be aborted by an older prompt's cleanup.
@@ -4006,7 +4265,7 @@ export function createNotificationsExtension(
 					);
 					return;
 				}
-				let proof: { status: "settled" } | { status: "unfenced" };
+				let proof: RunSettlementProof;
 				try {
 					proof = await seam.abortPromptAndWait(submission.executionHandle, {
 						graceMs: PROMPT_TERMINALIZATION_GRACE_MS,
@@ -4022,6 +4281,7 @@ export function createNotificationsExtension(
 					return;
 				}
 				if (proof?.status !== "settled") {
+					logger.warn(`sdk: prompt resource settlement unfenced: ${formatPromptSettlementDiagnostic(proof)}`);
 					// No settlement proof: never publish a normal terminal. The durable
 					// pending claim stays active so restart recovery finalizes it.
 					failPromptClosed(
@@ -4185,7 +4445,8 @@ export function createNotificationsExtension(
 		};
 
 		const sendSdkFrame = (connectionId: string, frame: Record<string, unknown>) => {
-			if (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime) {
+			const cancellation = frame.type === "reverse_cancel";
+			if (!cancellation && (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime)) {
 				abandonPromptResponse(connectionId, frame);
 				return;
 			}
@@ -4204,13 +4465,15 @@ 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;
 			}
 		};
@@ -4223,6 +4486,13 @@ 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 () => {
@@ -4230,6 +4500,11 @@ 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;
@@ -4521,6 +4796,47 @@ 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;
@@ -4528,6 +4844,13 @@ 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;
@@ -4536,6 +4859,7 @@ 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 : [];
@@ -4563,11 +4887,16 @@ export function createNotificationsExtension(
 			server.onConnectionClose((_err, connectionId) => {
 				if (!connectionId) return;
 				controlSurface.cancelPendingPreflightsForConnection(connectionId);
-				host.handleDisconnect(connectionId);
+				try {
+					host.handleDisconnect(connectionId);
+				} finally {
+					drainProviderReclaims(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
@@ -4848,7 +5177,9 @@ export function createNotificationsExtension(
 									!suspendedRuntime.stopping &&
 									!suspendedRuntime.policySuspended
 								)
-									inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
+									if (syntheticSeamAdmissions >= MAX_SYNTHETIC_SEAM_ADMISSIONS) return;
+								syntheticSeamAdmissions++;
+								inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
 							});
 						}
 					}
@@ -4857,6 +5188,8 @@ 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;
 					}

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

@@ -49,9 +49,11 @@ 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) while keeping the lifecycle contract moving strictly forward.
+ * 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.
  */
-export const DAEMON_GENERATION = 37;
+export const DAEMON_GENERATION = 39;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers