@gajae-code/coding-agent 0.12.6 → 0.12.7

package/src/sdk/bus/index.ts

@@ -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 { ReverseLeaseError, SessionSdkHost, shouldHostSdk } from "../host";
+import { 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";
@@ -3258,8 +3258,6 @@ export function createNotificationsExtension(
 				awaitStartup: boolean;
 		  }
 		| undefined;
-	const MAX_SYNTHETIC_SEAM_ADMISSIONS = 64;
-	let syntheticSeamAdmissions = 0;
 	let extensionShuttingDown = false;
 
 	async function ensureTelegramOwner(
@@ -3569,64 +3567,8 @@ export function createNotificationsExtension(
 		const revisions = new RevisionStore(id, Date.now, { storageDir: stateRoot });
 		let host: SessionSdkHost | undefined;
 		let disposeUiAnswerSource: (() => void) | undefined;
-		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,
-		) => {
+		const installProviderDefinitions = (capability: string, definitions: unknown) => {
 			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(
@@ -3664,179 +3606,6 @@ 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.
@@ -3868,17 +3637,11 @@ export function createNotificationsExtension(
 			};
 			if (!canRead) delete bridge.readTextFile;
 			if (!canWrite) delete bridge.writeTextFile;
-			fsClientBridge = bridge;
-			refreshSdkClientBridge();
+			ctx.setSdkClientBridge?.(bridge);
 		};
 		const removeProviderDefinitions = (capability: string) => {
 			if (capability === "permission") ctx.setSdkPermissionProvider?.(undefined);
-			if (capability === "fs") fsClientBridge = undefined;
-			if (capability === "terminal") {
-				terminalClientBridge = undefined;
-				terminalPublicationFailedLeaseId = undefined;
-			}
-			if (capability === "fs" || capability === "terminal") refreshSdkClientBridge();
+			if (capability === "fs") ctx.setSdkClientBridge?.(undefined);
 			if (capability === "ui") {
 				disposeUiAnswerSource?.();
 				disposeUiAnswerSource = undefined;
@@ -3886,12 +3649,6 @@ 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 };
@@ -4445,8 +4202,7 @@ export function createNotificationsExtension(
 		};
 
 		const sendSdkFrame = (connectionId: string, frame: Record<string, unknown>) => {
-			const cancellation = frame.type === "reverse_cancel";
-			if (!cancellation && (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime)) {
+			if (extensionShuttingDown || runtime?.stopping || runtimes.get(id) !== runtime) {
 				abandonPromptResponse(connectionId, frame);
 				return;
 			}
@@ -4465,15 +4221,13 @@ 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;
 			}
 		};
@@ -4486,13 +4240,6 @@ 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 () => {
@@ -4500,11 +4247,6 @@ 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;
@@ -4796,47 +4538,6 @@ 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;
@@ -4844,13 +4545,6 @@ 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;
@@ -4859,7 +4553,6 @@ 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 : [];
@@ -4887,16 +4580,11 @@ export function createNotificationsExtension(
 			server.onConnectionClose((_err, connectionId) => {
 				if (!connectionId) return;
 				controlSurface.cancelPendingPreflightsForConnection(connectionId);
-				try {
-					host.handleDisconnect(connectionId);
-				} finally {
-					drainProviderReclaims(connectionId);
-				}
+				host.handleDisconnect(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
@@ -5177,9 +4865,7 @@ export function createNotificationsExtension(
 									!suspendedRuntime.stopping &&
 									!suspendedRuntime.policySuspended
 								)
-									if (syntheticSeamAdmissions >= MAX_SYNTHETIC_SEAM_ADMISSIONS) return;
-								syntheticSeamAdmissions++;
-								inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
+									inboundSdkFrame?.(`seam:${inbound.requestId ?? "notification"}`, frame);
 							});
 						}
 					}
@@ -5188,8 +4874,6 @@ 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,11 +49,9 @@ 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.
  */
-export const DAEMON_GENERATION = 39;
+export const DAEMON_GENERATION = 38;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers