@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/sdk/bus/kind-aware-reconciliation.ts

@@ -1,19 +1,25 @@
+import { createHash, randomUUID } from "node:crypto";
+
 /**
  * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
- * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
+ * Preserves Q26 admit/first-terminal/capacity semantics; indexes and caps are per-kind.
  */
 
 import { sanitizePromptFailure } from "../prompt-failure";
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
+import type { ReceiptState } from "../receipt-state";
 import { sanitizeTurnResultContent, type TurnResultContent, type TurnResultPage } from "../turn-result";
-
 import {
 	PROMPT_RECONCILIATION_ACTIVE_CAPACITY,
 	PROMPT_RECONCILIATION_TERMINAL_CAPACITY,
-	PROMPT_RECONCILIATION_TERMINAL_TTL_MS,
 	type PromptCorrelation,
 } from "./prompt-reconciliation";
-import type { DurableReconciliationRecord, ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
+import type {
+	DurableReconciliationRecord,
+	DurableSteerReconciliationRecord,
+	ReconciliationKind,
+	ReconciliationStore,
+} from "./reconciliation-store";
 
 export type { ReconciliationKind };
 
@@ -22,6 +28,16 @@ export interface KindCorrelation extends PromptCorrelation {
 	content?: TurnResultContent;
 }
 
+export interface SteerReconciliationResult {
+	commandId: string;
+	turnId: string;
+	clientRef: string;
+	status: "accepted" | "rejected" | "uncertain";
+	acceptedAt: number;
+	terminalAt?: number;
+	error?: { code: string; message: string };
+}
+
 export interface KindAwareReconciliation {
 	admit(kind: ReconciliationKind, clientRef?: string): void;
 	releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
@@ -39,16 +55,19 @@ export interface KindAwareReconciliation {
 			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
 	): Promise<void>;
 	claimPendingOutcome(
+		kind: ReconciliationKind,
 		correlation: PromptCorrelation,
 		outcome: SdkPromptTerminalOutcome,
+		receiptState?: Extract<ReceiptState, "present" | "missing">,
 	): Promise<SdkPromptTerminalOutcome>;
-	finalizePromptOutcome(
+	finalizeOutcome(
+		kind: ReconciliationKind,
 		correlation: PromptCorrelation,
 		outcome?: SdkPromptTerminalOutcome,
 		recordError?: { code: string; message: string },
 		content?: unknown,
 	): Promise<void>;
-	peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
+	peekPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
 	lookup(
 		kind: ReconciliationKind,
 		selector: { commandId?: string; turnId?: string; clientRef?: string },
@@ -57,6 +76,15 @@ export interface KindAwareReconciliation {
 		kind: ReconciliationKind,
 		selector: { commandId?: string; turnId?: string; clientRef?: string },
 	): TurnResultPage;
+	reserveSteer(clientRef: string, text: string): Promise<{ replay: boolean; result: SteerReconciliationResult }>;
+	settleSteer(
+		clientRef: string,
+		status: "accepted" | "rejected" | "uncertain",
+		error?: unknown,
+	): Promise<SteerReconciliationResult>;
+	lookupSteer(
+		selector: string | { commandId?: string; turnId?: string; clientRef?: string },
+	): SteerReconciliationResult | { clientRef?: string; status: "unknown" };
 	cleanup(): void;
 	activeCount(kind: ReconciliationKind): number;
 	/** Hydrate from durable store (call once at session host start). */
@@ -77,28 +105,51 @@ export function createKindAwareReconciliation(
 	const keyOf = (kind: ReconciliationKind, correlation: PromptCorrelation) =>
 		`${kind}:${correlation.commandId}:${correlation.turnId}`;
 	const refKey = (kind: ReconciliationKind, clientRef: string) => `${kind}\0${clientRef}`;
+	const steerKey = (clientRef: string) => `steer:${clientRef}`;
+	const steerResult = (record: DurableSteerReconciliationRecord): SteerReconciliationResult => ({
+		commandId: record.commandId,
+		turnId: record.turnId,
+		clientRef: record.clientRef,
+		status: record.status === "dispatching" ? "uncertain" : record.status,
+		acceptedAt: record.acceptedAt,
+		...(record.status !== "dispatching" && record.status !== "accepted" ? { terminalAt: record.settledAt } : {}),
+		...(record.error
+			? { error: record.error }
+			: record.status === "dispatching"
+				? { error: { code: "delivery_uncertain", message: "Steer delivery is still dispatching or uncertain." } }
+				: {}),
+	});
 
 	const indexRecords = (source: Map<string, DurableReconciliationRecord>) => {
 		const index = new Map<string, string>();
 		for (const [key, record] of source)
-			if (record.clientRef !== undefined) index.set(refKey(record.kind, record.clientRef), key);
+			if (record.kind !== "steer" && record.clientRef !== undefined)
+				index.set(refKey(record.kind, record.clientRef), key);
 		return index;
 	};
 
 	const cleanupRecords = (source: Map<string, DurableReconciliationRecord>) => {
-		const at = now();
-		for (const [key, record] of source)
-			if (record.terminalAt !== undefined && record.terminalAt + PROMPT_RECONCILIATION_TERMINAL_TTL_MS <= at)
-				source.delete(key);
 		for (const kind of ["prompt", "skill"] as const) {
 			const terminalEntries = [...source.entries()].filter(
 				([, record]) => record.kind === kind && record.terminalAt !== undefined,
 			);
 			if (terminalEntries.length <= PROMPT_RECONCILIATION_TERMINAL_CAPACITY) continue;
-			terminalEntries.sort((a, b) => (a[1].terminalAt as number) - (b[1].terminalAt as number));
+			terminalEntries.sort(
+				(a, b) =>
+					((a[1].kind === "steer" ? a[1].settledAt : a[1].terminalAt) as number) -
+					((b[1].kind === "steer" ? b[1].settledAt : b[1].terminalAt) as number),
+			);
 			for (const [key] of terminalEntries.slice(0, terminalEntries.length - PROMPT_RECONCILIATION_TERMINAL_CAPACITY))
 				source.delete(key);
 		}
+		const settledSteers: Array<[string, DurableSteerReconciliationRecord]> = [];
+		for (const [key, record] of source)
+			if (record.kind === "steer" && record.settledAt !== undefined) settledSteers.push([key, record]);
+		if (settledSteers.length > PROMPT_RECONCILIATION_TERMINAL_CAPACITY) {
+			settledSteers.sort((a, b) => (a[1].settledAt as number) - (b[1].settledAt as number));
+			for (const [key] of settledSteers.slice(0, settledSteers.length - PROMPT_RECONCILIATION_TERMINAL_CAPACITY))
+				source.delete(key);
+		}
 	};
 
 	const queueMutation = async <T>(
@@ -122,6 +173,67 @@ export function createKindAwareReconciliation(
 		return await pending;
 	};
 
+	const reserveSteer = async (clientRef: string, text: string) => {
+		const textDigest = createHash("sha256").update(text).digest("hex");
+		return await queueMutation(candidate => {
+			cleanupRecords(candidate);
+			const existing = candidate.get(steerKey(clientRef));
+			if (existing?.kind === "steer") {
+				if (existing.textDigest !== textDigest)
+					throw Object.assign(new Error("clientRef is already bound to different steer text."), {
+						code: "client_ref_conflict",
+					});
+				return { value: { replay: true, result: steerResult(existing) }, changed: false };
+			}
+			const correlation = { commandId: randomUUID(), turnId: randomUUID() };
+			const record: DurableSteerReconciliationRecord = {
+				kind: "steer",
+				...correlation,
+				clientRef,
+				textDigest,
+				createdAt: now(),
+				acceptedAt: now(),
+				status: "dispatching",
+			};
+			candidate.set(steerKey(clientRef), record);
+			return { value: { replay: false, result: steerResult(record) }, changed: true };
+		});
+	};
+
+	const settleSteer = async (clientRef: string, status: "accepted" | "rejected" | "uncertain", error?: unknown) =>
+		await queueMutation(candidate => {
+			const record = candidate.get(steerKey(clientRef));
+			if (record?.kind !== "steer")
+				throw Object.assign(new Error("Unknown steer clientRef."), { code: "unknown_client_ref" });
+			if (record.status !== "dispatching") return { value: steerResult(record), changed: false };
+			record.status = status;
+			record.settledAt = now();
+			if (status !== "accepted") record.error = sanitizePromptFailure(error);
+			cleanupRecords(candidate);
+			return { value: steerResult(record), changed: true };
+		});
+
+	const lookupSteer = (selector: string | { commandId?: string; turnId?: string; clientRef?: string }) => {
+		const record =
+			typeof selector === "string"
+				? records.get(steerKey(selector))
+				: selector.clientRef !== undefined
+					? records.get(steerKey(selector.clientRef))
+					: selector.commandId !== undefined && selector.turnId !== undefined
+						? [...records.values()].find(
+								candidate =>
+									candidate.kind === "steer" &&
+									candidate.commandId === selector.commandId &&
+									candidate.turnId === selector.turnId,
+							)
+						: undefined;
+		return record?.kind === "steer"
+			? steerResult(record)
+			: typeof selector === "string"
+				? { clientRef: selector, status: "unknown" as const }
+				: { status: "unknown" as const };
+	};
+
 	const reservedFor = (kind: ReconciliationKind) => {
 		let set = reservedClientRefs.get(kind);
 		if (!set) {
@@ -138,7 +250,8 @@ export function createKindAwareReconciliation(
 
 	const activeCount = (kind: ReconciliationKind) => {
 		let count = 0;
-		for (const record of records.values()) if (record.kind === kind && record.terminalAt === undefined) count++;
+		for (const record of records.values())
+			if (record.kind !== "steer" && record.kind === kind && record.terminalAt === undefined) count++;
 		return count;
 	};
 
@@ -207,7 +320,7 @@ export function createKindAwareReconciliation(
 		if (!correlation) return;
 		await queueMutation(candidate => {
 			const record = candidate.get(keyOf(kind, correlation));
-			if (!record) return { value: undefined, changed: false };
+			if (!record || record.kind === "steer") return { value: undefined, changed: false };
 			if (record.terminalAt !== undefined) {
 				// The terminal is claimed by one delivery path while the reason arrives on
 				// another, so ordering is not the caller's to control. A late agent_failed
@@ -227,43 +340,61 @@ export function createKindAwareReconciliation(
 				record.status = "in_flight";
 				record.startedAt = now();
 				if (frame.content) record.content = sanitizeTurnResultContent(frame.content.text);
-
 				return { value: undefined, changed: true };
 			}
+			const pendingOutcome = record.pendingOutcome;
 			record.terminalAt = now();
 			if (frame.content) record.content = sanitizeTurnResultContent(frame.content.text);
-
-			if (frame.type === "agent_failed") {
+			if (pendingOutcome !== undefined) {
+				record.outcome = pendingOutcome;
+				record.pendingOutcome = undefined;
+				if (pendingOutcome.kind === "failed") {
+					record.status = "failed";
+					record.error = { code: pendingOutcome.code, message: pendingOutcome.message };
+				} else {
+					record.status = "terminal_ok";
+				}
+				record.receiptState = record.pendingReceiptState ?? "missing";
+				record.pendingReceiptState = undefined;
+			} else if (frame.type === "agent_failed") {
 				record.status = "failed";
 				record.error = sanitizePromptFailure(frame.error);
-			} else record.status = "terminal_ok";
+				record.receiptState = frame.content?.text?.trim() ? "present" : "missing";
+			} else {
+				record.status = "terminal_ok";
+				record.receiptState = frame.content?.text?.trim() ? "present" : "missing";
+			}
 			cleanupRecords(candidate);
 			return { value: undefined, changed: true };
 		});
 	};
 
 	const claimPendingOutcome = async (
+		kind: ReconciliationKind,
 		correlation: PromptCorrelation,
 		outcome: SdkPromptTerminalOutcome,
+		receiptState?: Extract<ReceiptState, "present" | "missing">,
 	): Promise<SdkPromptTerminalOutcome> =>
 		await queueMutation(candidate => {
-			const record = candidate.get(keyOf("prompt", correlation));
-			if (!record || record.terminalAt !== undefined || record.kind !== "prompt")
+			const record = candidate.get(keyOf(kind, correlation));
+			if (!record || record.terminalAt !== undefined || record.kind !== kind)
 				return { value: outcome, changed: false };
 			if (record.pendingOutcome !== undefined) return { value: record.pendingOutcome, changed: false };
 			record.pendingOutcome = outcome;
+			record.pendingReceiptState = receiptState;
 			return { value: outcome, changed: true };
 		});
 
-	const finalizePromptOutcome = async (
+	const finalizeOutcome = async (
+		kind: ReconciliationKind,
 		correlation: PromptCorrelation,
 		outcome?: SdkPromptTerminalOutcome,
 		recordError?: { code: string; message: string },
 		content?: unknown,
 	) => {
 		await queueMutation(candidate => {
-			const record = candidate.get(keyOf("prompt", correlation));
-			if (!record || record.terminalAt !== undefined || record.kind !== "prompt")
+			const record = candidate.get(keyOf(kind, correlation));
+			if (!record || record.terminalAt !== undefined || record.kind !== kind)
 				return { value: undefined, changed: false };
 			const finalOutcome = outcome ?? record.pendingOutcome;
 			record.terminalAt = now();
@@ -273,14 +404,16 @@ export function createKindAwareReconciliation(
 			} else record.status = "terminal_ok";
 			record.content = sanitizeTurnResultContent(content);
 			record.outcome = finalOutcome;
+			record.receiptState = record.pendingReceiptState ?? "unknown";
 			record.pendingOutcome = undefined;
+			record.pendingReceiptState = undefined;
 			cleanupRecords(candidate);
 			return { value: undefined, changed: true };
 		});
 	};
 
-	const peekPendingOutcome = (correlation: PromptCorrelation) =>
-		records.get(keyOf("prompt", correlation))?.pendingOutcome;
+	const peekPendingOutcome = (kind: ReconciliationKind, correlation: PromptCorrelation) =>
+		records.get(keyOf(kind, correlation))?.pendingOutcome;
 
 	const lookup = (
 		kind: ReconciliationKind,
@@ -294,20 +427,22 @@ export function createKindAwareReconciliation(
 					? keyOf(kind, { commandId: selector.commandId, turnId: selector.turnId })
 					: undefined;
 		const record = key === undefined ? undefined : records.get(key);
-		if (!record) return { status: "unknown" };
+		if (!record) return { status: "unknown", receiptState: "unknown" };
+		if (record.kind === "steer") return { status: "unknown", receiptState: "unknown" };
 		const identity = {
 			commandId: record.commandId,
 			turnId: record.turnId,
 			...(record.clientRef !== undefined ? { clientRef: record.clientRef } : {}),
 			acceptedAt: record.acceptedAt,
 		};
-		if (record.status === "accepted") return { status: "accepted", ...identity };
+		if (record.status === "accepted") return { status: "accepted", receiptState: "absent", ...identity };
 		if (record.status === "in_flight")
-			return { status: "in_flight", ...identity, startedAt: record.startedAt as number };
+			return { status: "in_flight", receiptState: "absent", ...identity, startedAt: record.startedAt as number };
 		const terminal = {
 			...identity,
 			...(record.startedAt !== undefined ? { startedAt: record.startedAt } : {}),
 			terminalAt: record.terminalAt as number,
+			receiptState: record.receiptState ?? "unknown",
 			...(record.outcome !== undefined ? { outcome: record.outcome } : {}),
 		};
 		if (record.status === "terminal_ok")
@@ -331,9 +466,11 @@ export function createKindAwareReconciliation(
 					? keyOf(kind, { commandId: selector.commandId, turnId: selector.turnId })
 					: undefined;
 		const record = key === undefined ? undefined : records.get(key);
-		if (!record) return { status: "unknown" };
+		if (!record || record.kind === "steer") return { status: "unknown" };
 		const identity = {
-			kind: record.kind,
+			// Durable terminal markers (kind "terminal") are not prompt/skill
+			// invocation pages: never surface them under a prompt/skill kind.
+			kind: record.kind === "terminal" ? undefined : record.kind,
 			commandId: record.commandId,
 			turnId: record.turnId,
 			...(record.clientRef !== undefined ? { clientRef: record.clientRef } : {}),
@@ -347,16 +484,46 @@ export function createKindAwareReconciliation(
 			terminalAt: record.terminalAt as number,
 			...(record.content !== undefined ? { content: record.content } : {}),
 		};
-		if (record.status === "terminal_ok") return { status: "terminal_ok", ...terminal };
+		if (record.status === "terminal_ok")
+			return {
+				status: "terminal_ok",
+				...terminal,
+				...(record.error !== undefined ? { error: record.error } : {}),
+			};
 		return { status: "failed", ...terminal, error: record.error ?? sanitizePromptFailure(undefined) };
 	};
 	const hydrateFromStore = async () => {
 		if (!store) return;
 		const run = async () => {
 			const loaded = await store.load();
-			const candidate = new Map(loaded.map(record => [keyOf(record.kind, record), { ...record }] as const));
+			const candidate = new Map(
+				loaded.map(record => {
+					const hydrated =
+						record.kind === "steer" && record.status === "accepted"
+							? {
+									...record,
+									status: "uncertain" as const,
+									settledAt: now(),
+									error: {
+										code: "process_restart_uncertain",
+										message: "Steer delivery cannot be proven after process restart.",
+									},
+								}
+							: { ...record };
+					return [
+						record.kind === "steer" ? steerKey(record.clientRef) : keyOf(record.kind, record),
+						hydrated,
+					] as const;
+				}),
+			);
 			const candidateIndex = indexRecords(candidate);
-			await store.transact(() => [...candidate.values()].map(record => ({ ...record })));
+			// Persist only when hydration settled accepted steers to uncertain: an
+			// unconditional transact emits a rename on every startup even for empty
+			// stores, which a test pause hook or slow fs can intercept before any
+			// prompt/skill admission — stalling reconciliationReady so a concurrent
+			// abort misses the not-yet-registered pending preflight entry (#4522).
+			const settledSteers = loaded.some(record => record.kind === "steer" && record.status === "accepted");
+			if (settledSteers) await store.transact(() => [...candidate.values()].map(record => ({ ...record })));
 			records = candidate;
 			clientRefIndex = candidateIndex;
 		};
@@ -374,13 +541,16 @@ export function createKindAwareReconciliation(
 		noteAccepted,
 		noteTransition,
 		claimPendingOutcome,
-		finalizePromptOutcome,
+		finalizeOutcome,
 		peekPendingOutcome,
 		lookup,
 		lookupResult,
 		cleanup,
 		activeCount,
 		hydrateFromStore,
+		reserveSteer,
+		settleSteer,
+		lookupSteer,
 	};
 }
 

package/src/sdk/bus/lifecycle-commands.ts

@@ -293,13 +293,13 @@ function isSafeBranch(value: string): boolean {
 export function formatLifecycleOutcome(r: SessionLifecycleResponse, verb?: LifecycleCommandVerb): string {
 	switch (r.type) {
 		case "session_create_response":
-			return `\u{1f680} Launching session ${r.sessionId} in tmux. It will appear once ready \u2014 check /session_recent.`;
+			return `\u{1f680} Launching session ${r.sessionId} through SDK core. It will appear once ready — check /session_recent.`;
 		case "session_close_response":
 			return `\u2705 Closed session ${r.sessionId} (history preserved \u2014 you can resume it later).`;
 		case "session_resume_response":
 			return r.mode === "reattached"
 				? `\u2705 Reattached to live session ${r.sessionId}.`
-				: `\u{1f680} Cold-restarting session ${r.sessionId} from saved history in tmux \u2014 check /session_recent.`;
+				: `\u{1f680} Resuming session ${r.sessionId} from saved history through SDK core — check /session_recent.`;
 		case "session_lifecycle_error":
 			break;
 		default:

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

@@ -1,163 +1,20 @@
-import * as path from "node:path";
-import type { Settings } from "../../config/settings";
 import { RateLimitPool } from "./rate-limit-pool";
-import {
-	CLIENT_PING_PONG_CAPABILITY,
-	HEARTBEAT_INTERVAL_MS,
-	HEARTBEAT_TTL_MS,
-	NOTIFICATION_PROTOCOL_VERSION,
-} from "./telegram-daemon";
-import { readEndpoint } from "./telegram-reference";
 import { renderThreadedFrame, type ThreadedSend } from "./threaded-render";
 
-export interface ManagedNotificationDaemonFs {
-	readdir(path: string): Promise<string[]>;
-}
-
-export interface ManagedSessionSocket {
-	sessionId: string;
-	token: string;
-	ws: WebSocket;
-	pending: Map<string, { sessionId: string; actionId: string }>;
-	capable: boolean;
-	lastPongAt: number;
-	awaitingNonce: string | undefined;
-	pingTimer: ReturnType<typeof setInterval> | undefined;
-}
-
+/** Shared presentation engine for managed notification providers. */
 export interface ManagedNotificationDaemonOptions {
-	settings: Settings;
-	fs: ManagedNotificationDaemonFs;
-	WebSocketImpl?: typeof WebSocket;
 	now?: () => number;
-	setIntervalImpl?: typeof setInterval;
-	clearIntervalImpl?: typeof clearInterval;
 	rateLimitPool?: RateLimitPool<{ send: ThreadedSend; topicId?: string }>;
 }
 
 export abstract class ManagedNotificationDaemon {
-	readonly sessions = new Map<string, ManagedSessionSocket>();
 	readonly pool: RateLimitPool<{ send: ThreadedSend; topicId?: string }>;
 
-	protected constructor(protected readonly opts: ManagedNotificationDaemonOptions) {
+	protected constructor(opts: ManagedNotificationDaemonOptions = {}) {
 		this.pool = opts.rateLimitPool ?? new RateLimitPool<{ send: ThreadedSend; topicId?: string }>({ now: opts.now });
 	}
 
-	async scanRoots(): Promise<void> {
-		const rootState = await this.readRoots();
-		for (const root of rootState) {
-			const dir = path.join(root, "sdk");
-			let files: string[];
-			try {
-				files = await this.opts.fs.readdir(dir);
-			} catch {
-				continue;
-			}
-			for (const file of files.filter(item => item.endsWith(".json"))) {
-				const sessionId = path.basename(file, ".json");
-				if (this.sessions.has(sessionId)) continue;
-				try {
-					const endpoint = readEndpoint(path.join(dir, file));
-					this.connectSession(sessionId, endpoint.url, endpoint.token);
-				} catch {}
-			}
-		}
-	}
-
-	connectSession(sessionId: string, url: string, token: string): ManagedSessionSocket {
-		const WS = this.opts.WebSocketImpl ?? WebSocket;
-		const ws = new WS(`${url}/?token=${encodeURIComponent(token)}`);
-		const session: ManagedSessionSocket = {
-			sessionId,
-			token,
-			ws,
-			pending: new Map(),
-			capable: false,
-			lastPongAt: 0,
-			awaitingNonce: undefined,
-			pingTimer: undefined,
-		};
-		this.sessions.set(sessionId, session);
-		ws.addEventListener("open", () => this.sendHello(session));
-		ws.addEventListener("message", ev => {
-			if (this.sessions.get(sessionId) !== session) return;
-			void this.handleSessionMessage(session, JSON.parse(String(ev.data))).catch(() => undefined);
-		});
-		ws.addEventListener("close", () => this.dropSession(session));
-		return session;
-	}
-
-	protected async handleSessionMessage(session: ManagedSessionSocket, msg: Record<string, unknown>): Promise<boolean> {
-		if (msg.type === "hello") {
-			const caps = Array.isArray(msg.capabilities) ? msg.capabilities : [];
-			if (caps.includes(CLIENT_PING_PONG_CAPABILITY)) {
-				session.capable = true;
-				this.startLiveness(session);
-			}
-			return true;
-		}
-		if (msg.type === "pong") {
-			if (typeof msg.nonce === "string" && msg.nonce === session.awaitingNonce) {
-				session.awaitingNonce = undefined;
-				session.lastPongAt = (this.opts.now ?? Date.now)();
-			}
-			return true;
-		}
-		return false;
-	}
-
 	protected renderFrame(frame: Record<string, unknown>): ThreadedSend | undefined {
 		return renderThreadedFrame(frame);
 	}
-
-	protected dropSession(session: ManagedSessionSocket): void {
-		const clearIntervalImpl = this.opts.clearIntervalImpl ?? clearInterval;
-		if (session.pingTimer) {
-			clearIntervalImpl(session.pingTimer);
-			session.pingTimer = undefined;
-		}
-		if (this.sessions.get(session.sessionId) === session) this.sessions.delete(session.sessionId);
-		if (session.ws.readyState !== WebSocket.CLOSED) {
-			try {
-				session.ws.close();
-			} catch {}
-		}
-	}
-
-	protected abstract readRoots(): Promise<string[]>;
-
-	private sendHello(session: ManagedSessionSocket): void {
-		if (session.ws.readyState !== WebSocket.OPEN) return;
-		try {
-			session.ws.send(
-				JSON.stringify({
-					type: "hello",
-					protocolVersion: NOTIFICATION_PROTOCOL_VERSION,
-					capabilities: [CLIENT_PING_PONG_CAPABILITY],
-				}),
-			);
-		} catch {}
-	}
-
-	private startLiveness(session: ManagedSessionSocket): void {
-		if (session.pingTimer) return;
-		const setIntervalImpl = this.opts.setIntervalImpl ?? setInterval;
-		const now = () => (this.opts.now ?? Date.now)();
-		session.lastPongAt = now();
-		session.pingTimer = setIntervalImpl(() => {
-			if (this.sessions.get(session.sessionId) !== session) return;
-			const t = now();
-			if (t - session.lastPongAt >= HEARTBEAT_TTL_MS) {
-				this.dropSession(session);
-				return;
-			}
-			if (session.ws.readyState === WebSocket.OPEN) {
-				const nonce = `${session.sessionId}:${t}:${Math.random().toString(36).slice(2)}`;
-				session.awaitingNonce = nonce;
-				try {
-					session.ws.send(JSON.stringify({ type: "ping", nonce }));
-				} catch {}
-			}
-		}, HEARTBEAT_INTERVAL_MS);
-	}
 }