@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/src/harness-control-plane/receipt-spool.ts

@@ -21,6 +21,46 @@ export interface ReceiptSpoolAppendResult {
 const receiptSpoolDirStorage = new AsyncLocalStorage<string | undefined>();
 const spoolQueues = new Map<string, Promise<void>>();
 const noop = (): void => undefined;
+
+interface ReceiptSpoolCursorCache {
+	mtimeMs: number;
+	size: number;
+	highest: bigint;
+}
+
+const cursorCache = new Map<string, ReceiptSpoolCursorCache>();
+let fullScanCount = 0;
+
+/** @internal Test-only instrumentation for steady-state spool scan coverage. */
+export function receiptSpoolFullScanCountForTesting(): number {
+	return fullScanCount;
+}
+
+/** @internal Test-only cache reset. */
+export function resetReceiptSpoolCursorCacheForTesting(): void {
+	cursorCache.clear();
+	fullScanCount = 0;
+}
+
+async function spoolStat(spoolFile: string): Promise<{ mtimeMs: number; size: number } | undefined> {
+	try {
+		const stats = await fs.stat(spoolFile);
+		return { mtimeMs: stats.mtimeMs, size: stats.size };
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+function sameSpoolRevision(a: ReceiptSpoolCursorCache, b: { mtimeMs: number; size: number }): boolean {
+	return a.mtimeMs === b.mtimeMs && a.size === b.size;
+}
+
+async function cacheHighestCursor(spoolFile: string, highest: bigint): Promise<void> {
+	const revision = await spoolStat(spoolFile);
+	if (revision) cursorCache.set(spoolFile, { ...revision, highest });
+}
+
 export async function withReceiptSpoolDir<T>(spoolDir: string, fn: () => Promise<T>): Promise<T> {
 	const trimmed = spoolDir.trim();
 	if (!trimmed) throw new Error("receipt_spool_dir_empty");
@@ -55,14 +95,16 @@ export function formatReceiptSpoolCursor(cursor: bigint): string {
 
 export async function readHighestReceiptSpoolCursor(spoolDir: string): Promise<bigint> {
 	const spoolFile = receiptSpoolPath(spoolDir);
-	let raw: string;
-	try {
-		raw = await fs.readFile(spoolFile, "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return 0n;
-		throw error;
+	const revision = await spoolStat(spoolFile);
+	if (!revision) {
+		cursorCache.delete(spoolFile);
+		return 0n;
 	}
+	const cached = cursorCache.get(spoolFile);
+	if (cached && sameSpoolRevision(cached, revision)) return cached.highest;
 
+	fullScanCount++;
+	const raw = await fs.readFile(spoolFile, "utf8");
 	let highest = 0n;
 	for (const line of raw.split("\n")) {
 		const trimmed = line.trim();
@@ -72,9 +114,10 @@ export async function readHighestReceiptSpoolCursor(spoolDir: string): Promise<b
 			const cursor = parseCursor(parsed.cursor);
 			if (cursor !== undefined && cursor > highest) highest = cursor;
 		} catch {
-			// A crash may leave a torn tail; consumers skip malformed lines and so do we.
+			// A crash may leave a torn tail; a full scan ignores it and re-establishes the cache.
 		}
 	}
+	cursorCache.set(spoolFile, { ...revision, highest });
 	return highest;
 }
 
@@ -111,6 +154,7 @@ export async function appendReceiptToSpool(
 				} finally {
 					await handle.close();
 				}
+				await cacheHighestCursor(spoolFile, BigInt(cursor));
 				return { cursor, path: spoolFile };
 			},
 			{ staleMs: 30_000, retries: 100, retryDelayMs: 25 },

package/src/harness-control-plane/receipts.ts

@@ -163,7 +163,6 @@ export interface VanishEvidence {
 
 export interface PromptAcceptanceEvidence {
 	promptSha256: string;
-	rpcCommandId: string;
 	preSubmitState: { isStreaming: boolean; steeringQueueDepth: number; followupQueueDepth: number };
 	preSubmitCursor: number;
 	agentStartCursor: number;

package/src/harness-control-plane/sdk-transport.ts

@@ -0,0 +1,395 @@
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+import { readSdkSessionEndpoint, SdkClient } from "../sdk/client";
+import type { HarnessSessionTransport, SessionStateSnapshot } from "./session-transport";
+
+const DISCOVERY_TIMEOUT_MS = 10_000;
+const DISCOVERY_POLL_MS = 50;
+const TERM_GRACE_MS = 2_000;
+const KILL_VERIFY_MS = 1_000;
+
+export class HarnessSdkTransportError extends Error {
+	constructor(
+		readonly code: "endpoint_unavailable" | "invalid_response",
+		message: string,
+		readonly cause?: unknown,
+	) {
+		super(message);
+		this.name = "HarnessSdkTransportError";
+	}
+}
+
+export interface SpawnedHarnessSession {
+	stop(): Promise<void>;
+}
+
+export interface CreateSdkSessionTransportOptions {
+	repo: string;
+	sessionId: string;
+	/** Starts the normal SKC session before discovery. Test callers may provide a deterministic SDK host. */
+	spawn?: () => SpawnedHarnessSession | Promise<SpawnedHarnessSession>;
+	discoveryTimeoutMs?: number;
+	/** Test seam: inject SDK client/endpoint resolution to avoid a process-global module mock. */
+	connect?: typeof SdkClient.connect;
+	readEndpoint?: (repo: string, sessionId: string) => Promise<{ url: string; token: string } | null>;
+}
+
+function invalidResponse(detail: string): never {
+	throw new HarnessSdkTransportError("invalid_response", detail);
+}
+
+function record(value: unknown, detail = "SDK returned a non-object response."): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) invalidResponse(detail);
+	return value as Record<string, unknown>;
+}
+
+function stringAt(value: Record<string, unknown>, key: string, detail: string): string {
+	const candidate = value[key];
+	if (typeof candidate !== "string" || candidate.length === 0) invalidResponse(detail);
+	return candidate;
+}
+
+function nonNegativeIntegerAt(value: Record<string, unknown>, key: string, detail: string): number {
+	const candidate = value[key];
+	if (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0) invalidResponse(detail);
+	return candidate;
+}
+
+function queryItem(value: unknown, query: string): Record<string, unknown> {
+	const response = record(value, `SDK ${query} response was not an object.`);
+	if (response.type !== "query_response" || response.ok !== true || typeof response.id !== "string")
+		invalidResponse(`SDK ${query} response had an invalid envelope.`);
+	const page = record(response.page, `SDK ${query} response was missing a page.`);
+	if (page.complete !== true || typeof page.revision !== "string")
+		invalidResponse(`SDK ${query} response had an invalid page.`);
+	const items = page.items;
+	if (!Array.isArray(items) || items.length !== 1)
+		invalidResponse(`SDK ${query} response did not contain exactly one item.`);
+	return record(items[0], `SDK ${query} response item was not an object.`);
+}
+
+function metadataItem(value: unknown): void {
+	const metadata = queryItem(value, "session.metadata");
+	for (const key of ["sessionId", "name", "cwd", "kind"])
+		stringAt(metadata, key, "SDK session.metadata response was missing required fields.");
+}
+
+function contextItem(value: unknown): SessionStateSnapshot {
+	const context = queryItem(value, "context.get");
+	if (typeof context.isStreaming !== "boolean") invalidResponse("SDK context.get response was missing isStreaming.");
+	return {
+		isStreaming: context.isStreaming,
+		steeringQueueDepth: nonNegativeIntegerAt(
+			context,
+			"steeringQueueDepth",
+			"SDK context.get response had an invalid steeringQueueDepth.",
+		),
+		followupQueueDepth: nonNegativeIntegerAt(
+			context,
+			"followupQueueDepth",
+			"SDK context.get response had an invalid followupQueueDepth.",
+		),
+	};
+}
+
+function replayEvents(value: unknown): Record<string, unknown>[] {
+	const response = record(value, "SDK event replay response was not an object.");
+	if (response.type !== "event_replay_result" || response.ok !== true || typeof response.id !== "string")
+		invalidResponse("SDK event replay response had an invalid envelope.");
+	nonNegativeIntegerAt(response, "generation", "SDK event replay response had an invalid generation.");
+	nonNegativeIntegerAt(response, "lastSeq", "SDK event replay response had an invalid lastSeq.");
+	if (!Array.isArray(response.events)) invalidResponse("SDK event replay response was missing events.");
+	return response.events.map(event => record(event, "SDK event replay response contained a malformed event."));
+}
+
+function acceptedPrompt(value: unknown): string {
+	const response = record(value, "SDK control response was not an object.");
+	if (response.type !== "control_response" || response.ok !== true || typeof response.id !== "string")
+		invalidResponse("SDK control response had an invalid envelope.");
+	const result = record(response.result, "SDK control response was missing a result.");
+	// Only a literal accepted:true acknowledges the prompt; false, missing, or
+	// any non-boolean value is a contract violation, never a silent acceptance.
+	if (result.accepted !== true) invalidResponse("SDK control response did not accept the prompt.");
+	return stringAt(result, "commandId", "SDK control response was missing commandId.");
+}
+
+function sdkEventToAgentWire(frame: Record<string, unknown>): Record<string, unknown> {
+	if (frame.type !== "event") return frame;
+	const payload = frame.payload;
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return frame;
+	const event = payload as Record<string, unknown>;
+	const eventType =
+		typeof event.type === "string" ? event.type : typeof event.kind === "string" ? event.kind : undefined;
+	return eventType ? { type: "event", payload: { event_type: eventType, event } } : frame;
+}
+
+/**
+ * Connects an owner to the child session's public SDK endpoint. The SDK client owns
+ * hello-gated reconnects; this adapter only owns the bounded discovery wait and child
+ * lifecycle.
+ */
+export async function createSdkSessionTransport(
+	options: CreateSdkSessionTransportOptions,
+): Promise<HarnessSessionTransport> {
+	let child: SpawnedHarnessSession | undefined;
+	const readEndpoint = options.readEndpoint ?? readSdkSessionEndpoint;
+	let endpoint = await readEndpoint(options.repo, options.sessionId);
+	if (!endpoint && options.spawn) child = await options.spawn();
+	const timeoutMs = options.discoveryTimeoutMs ?? DISCOVERY_TIMEOUT_MS;
+	const deadline = Date.now() + timeoutMs;
+	while (!endpoint && Date.now() < deadline) {
+		await new Promise(resolve => setTimeout(resolve, DISCOVERY_POLL_MS));
+		try {
+			endpoint = await readEndpoint(options.repo, options.sessionId);
+		} catch (error) {
+			// A discovery read that fails after spawn must not orphan the spawned child;
+			// await stop before propagating, preserving both causes on dual failure (no double stop).
+			try {
+				await child?.stop();
+			} catch (cleanupError) {
+				throw new AggregateError(
+					[error, cleanupError],
+					"SDK endpoint discovery and spawned harness child cleanup both failed.",
+				);
+			}
+			throw error;
+		}
+	}
+	if (!endpoint) {
+		const timeoutError = new HarnessSdkTransportError(
+			"endpoint_unavailable",
+			`SDK endpoint for harness session ${options.sessionId} did not appear within ${timeoutMs}ms.`,
+		);
+		try {
+			// Await child stop so a discovery timeout never orphans the spawned session.
+			await child?.stop();
+		} catch (cleanupError) {
+			throw new AggregateError(
+				[timeoutError, cleanupError],
+				"SDK endpoint discovery timed out and spawned harness child cleanup failed.",
+			);
+		}
+		throw timeoutError;
+	}
+
+	let client: SdkClient;
+	try {
+		client = await (options.connect ?? SdkClient.connect)(endpoint.url, endpoint.token);
+	} catch (error) {
+		try {
+			await child?.stop();
+		} catch (cleanupError) {
+			throw new AggregateError(
+				[error, cleanupError],
+				"SDK connection and spawned harness child cleanup both failed.",
+			);
+		}
+		throw error;
+	}
+	let cursor = 0;
+	let lastFrameAt: string | null = null;
+	let live = true;
+	const frames = new Set<(frame: Record<string, unknown>) => void>();
+	client.onFrame(frame => {
+		if (frame.type === "hello" || frame.type === "server_hello") return;
+		cursor += 1;
+		lastFrameAt = new Date().toISOString();
+		const normalized = sdkEventToAgentWire(frame);
+		for (const listener of frames) listener(normalized);
+	});
+	client.onReconnectFailed(() => {
+		live = false;
+	});
+
+	const replay = async (): Promise<void> => {
+		const response = await client.request({
+			type: "event_replay",
+			id: randomUUID(),
+			sinceGeneration: 0,
+			sinceSeq: 0,
+		});
+		for (const event of replayEvents(response)) {
+			cursor += 1;
+			lastFrameAt = new Date().toISOString();
+			const normalized = sdkEventToAgentWire(event);
+			for (const listener of frames) listener(normalized);
+		}
+	};
+	try {
+		await replay();
+	} catch (error) {
+		const failures: unknown[] = [error];
+		try {
+			await client.close();
+		} catch (cleanupError) {
+			failures.push(cleanupError);
+		}
+		try {
+			await child?.stop();
+		} catch (cleanupError) {
+			failures.push(cleanupError);
+		}
+		if (failures.length > 1) throw new AggregateError(failures, "SDK replay and harness child cleanup failed.");
+		throw error;
+	}
+
+	return {
+		async getState(): Promise<SessionStateSnapshot> {
+			const [metadata, context] = await Promise.all([client.query("session.metadata"), client.query("context.get")]);
+			metadataItem(metadata);
+			return contextItem(context);
+		},
+		async sendPrompt(prompt: string): Promise<{ commandId: string; ack: boolean }> {
+			return {
+				commandId: acceptedPrompt(
+					await client.control("turn.prompt", { text: prompt }, { idempotencyKey: randomUUID() }),
+				),
+				ack: true,
+			};
+		},
+		eventCursor: () => cursor,
+		async waitForAgentStart(afterCursor: number, timeout: number): Promise<{ cursor: number } | null> {
+			return await new Promise(resolve => {
+				const listener = (frame: Record<string, unknown>): void => {
+					const payload = frame.payload;
+					const event =
+						payload && typeof payload === "object" && !Array.isArray(payload)
+							? (payload as Record<string, unknown>)
+							: {};
+					if (cursor > afterCursor && event.event_type === "agent_start") {
+						clearTimeout(timer);
+						frames.delete(listener);
+						resolve({ cursor });
+					}
+				};
+				frames.add(listener);
+				const timer = setTimeout(() => {
+					frames.delete(listener);
+					resolve(null);
+				}, timeout);
+			});
+		},
+		onEventFrame(listener) {
+			frames.add(listener);
+			return () => frames.delete(listener);
+		},
+		isLive: () => live,
+		lastFrameAt: () => lastFrameAt,
+		async getLastAssistantText(): Promise<string | null> {
+			const value = queryItem(await client.query("session.last_assistant"), "session.last_assistant");
+			return typeof value.text === "string" ? value.text : typeof value.content === "string" ? value.content : null;
+		},
+		async close(): Promise<void> {
+			live = false;
+			const failures: unknown[] = [];
+			try {
+				await client.close();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				// Await child stop so close never orphans the spawned session.
+				await child?.stop();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length > 1)
+				throw new AggregateError(failures, "SDK client and harness child cleanup both failed.");
+			if (failures.length === 1) throw failures[0];
+		},
+	};
+}
+
+export interface ReapableHarnessChild {
+	kill(signal?: number | NodeJS.Signals): void;
+	readonly exited: Promise<number>;
+	readonly exitCode: number | null;
+}
+
+/**
+ * Stop an exact spawned child: SIGTERM with bounded grace, SIGKILL escalation, then
+ * authoritative `child.exited` verification. A rejected exit promise is NOT proof of exit
+ * and therefore fails closed after SIGKILL rather than being mistaken for termination.
+ * Failure to verify exit after SIGKILL throws — the caller must not assume the child died.
+ */
+async function reapChild(child: ReapableHarnessChild, termGraceMs: number, killVerifyMs: number): Promise<void> {
+	const exited = child.exited.then(
+		() => true,
+		() => false,
+	);
+	const send = (signal: NodeJS.Signals): void => {
+		if (child.exitCode !== null) return;
+		try {
+			child.kill(signal);
+		} catch {
+			// Kill may fail if the child already exited; the exited race below is authoritative.
+		}
+	};
+	if (child.exitCode !== null) return;
+	send("SIGTERM");
+	let verified = await Promise.race([exited, Bun.sleep(termGraceMs).then(() => false)]);
+	if (!verified) {
+		send("SIGKILL");
+		verified = await Promise.race([exited, Bun.sleep(killVerifyMs).then(() => false)]);
+	}
+	if (!verified) {
+		throw new HarnessSdkTransportError("endpoint_unavailable", "Harness child session did not exit after SIGKILL.");
+	}
+}
+
+function ownedHarnessSession(
+	child: ReapableHarnessChild,
+	termGraceMs: number,
+	killVerifyMs: number,
+): SpawnedHarnessSession {
+	let stopPromise: Promise<void> | null = null;
+	return {
+		stop(): Promise<void> {
+			if (stopPromise) return stopPromise;
+			const pending = reapChild(child, termGraceMs, killVerifyMs);
+			stopPromise = pending;
+			void pending.catch(() => {
+				if (stopPromise === pending) stopPromise = null;
+			});
+			return pending;
+		},
+	};
+}
+
+export function spawnNormalHarnessSession(
+	repo: string,
+	sessionId: string,
+	options: { termGraceMs?: number; killVerifyMs?: number } = {},
+): SpawnedHarnessSession {
+	const entry = process.argv[1];
+	if (process.env.SKC_SDK_DISABLE === "1") {
+		throw new HarnessSdkTransportError(
+			"endpoint_unavailable",
+			"SDK hosting is disabled for the harness child session.",
+		);
+	}
+	if (!entry)
+		throw new HarnessSdkTransportError(
+			"endpoint_unavailable",
+			"Cannot determine the SKC CLI entrypoint for harness session startup.",
+		);
+	const child = Bun.spawn([process.execPath, path.resolve(entry)], {
+		cwd: repo,
+		env: { ...process.env, SKC_LIFECYCLE_REQUEST_ID: `harness-${sessionId}`, SKC_SESSION_ID: sessionId },
+		terminal: { cols: 80, rows: 24 },
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+	child.unref();
+	const termGraceMs = options.termGraceMs ?? TERM_GRACE_MS;
+	const killVerifyMs = options.killVerifyMs ?? KILL_VERIFY_MS;
+	return ownedHarnessSession(child, termGraceMs, killVerifyMs);
+}
+
+/** Test hook for exact-child stop serialization and retry semantics. */
+export function ownedHarnessSessionForTest(
+	child: ReapableHarnessChild,
+	options: { termGraceMs?: number; killVerifyMs?: number } = {},
+): SpawnedHarnessSession {
+	return ownedHarnessSession(child, options.termGraceMs ?? TERM_GRACE_MS, options.killVerifyMs ?? KILL_VERIFY_MS);
+}

package/src/harness-control-plane/session-lease.ts

@@ -9,6 +9,8 @@
 import { createHash, randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { withFileLock } from "../config/file-lock";
+
 import { controlSocketPath, sessionPaths } from "./storage";
 
 export interface SessionLease {
@@ -51,21 +53,8 @@ async function writeLeaseAtomic(file: string, lease: SessionLease): Promise<void
 	await fs.writeFile(tmp, `${JSON.stringify(lease, null, 2)}\n`, "utf8");
 	await fs.rename(tmp, file);
 }
-const LEASE_LOCK_RETRIES = 100;
-const LEASE_LOCK_RETRY_DELAY_MS = 20;
-const LEASE_LOCK_FILE_SUFFIX = ".json";
-
-interface LeaseLockInfo {
-	pid: number;
-	token: string;
-}
-
 function leaseMutationLockPath(root: string, sessionId: string): string {
-	return `${sessionPaths(root, sessionId).lease}.lock`;
-}
-
-function leaseMutationLockFile(lockPath: string, token: string): string {
-	return path.join(lockPath, `${token}${LEASE_LOCK_FILE_SUFFIX}`);
+	return sessionPaths(root, sessionId).lease;
 }
 
 function isOwnedUnixEndpointPath(root: string, sessionId: string, endpointPath: string, fallbackPath: string): boolean {
@@ -77,128 +66,21 @@ function isOwnedUnixEndpointPath(root: string, sessionId: string, endpointPath:
 		return false;
 	}
 }
-
-function isPathExistsError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException).code;
-	return code === "EEXIST" || code === "ENOTEMPTY" || code === "EISDIR" || code === "ENOTDIR";
-}
-
-function isIgnorableLockDirRemoveError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException).code;
-	return code === "ENOENT" || code === "ENOTEMPTY" || code === "EEXIST";
-}
-
-async function removeEmptyLockDir(lockPath: string): Promise<void> {
-	try {
-		await fs.rmdir(lockPath);
-	} catch (error) {
-		if (!isIgnorableLockDirRemoveError(error)) throw error;
-	}
-}
-
-function parseLeaseLockInfo(raw: string): LeaseLockInfo | null {
-	try {
-		const parsed = JSON.parse(raw) as unknown;
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-		const info = parsed as Record<string, unknown>;
-		return typeof info.pid === "number" && typeof info.token === "string"
-			? { pid: info.pid, token: info.token }
-			: null;
-	} catch {
-		return null;
-	}
-}
-
-async function readLeaseLockInfo(lockFile: string): Promise<LeaseLockInfo | null> {
-	try {
-		return parseLeaseLockInfo(await fs.readFile(lockFile, "utf8"));
-	} catch {
-		return null;
-	}
-}
-
-async function createLeaseMutationLock(lockPath: string, info: LeaseLockInfo): Promise<boolean> {
-	const tmpPath = `${lockPath}.tmp-${info.token}`;
-	await fs.rm(tmpPath, { recursive: true, force: true });
-	await fs.mkdir(tmpPath, { mode: 0o700 });
+async function withLeaseMutationLock<T>(root: string, sessionId: string, fn: () => Promise<T>): Promise<T> {
+	const lockPath = leaseMutationLockPath(root, sessionId);
+	await fs.mkdir(path.dirname(lockPath), { recursive: true });
 	try {
-		await fs.writeFile(leaseMutationLockFile(tmpPath, info.token), `${JSON.stringify(info)}\n`, {
-			encoding: "utf8",
-			mode: 0o600,
+		return await withFileLock(lockPath, fn, {
+			staleMs: 30_000,
+			retries: 100,
+			retryDelayMs: 20,
 		});
-		await fs.rename(tmpPath, lockPath);
-		return true;
-	} catch (error) {
-		await fs.rm(tmpPath, { recursive: true, force: true });
-		if (isPathExistsError(error)) return false;
-		throw error;
-	}
-}
-
-async function recoverLegacyStaleLeaseLock(lockPath: string): Promise<void> {
-	const info = await readLeaseLockInfo(lockPath);
-	if (!info || defaultPidStatusProbe(info.pid) !== "dead") return;
-	try {
-		await fs.unlink(lockPath);
 	} catch (error) {
-		const code = (error as NodeJS.ErrnoException).code;
-		if (code !== "ENOENT" && code !== "EISDIR") throw error;
-	}
-}
-
-async function recoverStaleLeaseMutationLock(lockPath: string): Promise<void> {
-	let entries: string[];
-	try {
-		entries = await fs.readdir(lockPath);
-	} catch (error) {
-		const code = (error as NodeJS.ErrnoException).code;
-		if (code === "ENOENT") return;
-		if (code === "ENOTDIR") {
-			await recoverLegacyStaleLeaseLock(lockPath);
-			return;
+		if (error instanceof Error && error.message.startsWith("Failed to acquire lock")) {
+			throw new LeaseError(`lease_lock_timeout:${sessionId}`, "lease_lock_timeout");
 		}
 		throw error;
 	}
-	const lockFiles = entries.filter(entry => entry.endsWith(LEASE_LOCK_FILE_SUFFIX));
-	if (lockFiles.length === 0) {
-		await removeEmptyLockDir(lockPath);
-		return;
-	}
-	if (lockFiles.length !== 1) return;
-	const lockFile = lockFiles[0];
-	const info = await readLeaseLockInfo(path.join(lockPath, lockFile));
-	if (!info || lockFile !== `${info.token}${LEASE_LOCK_FILE_SUFFIX}`) return;
-	if (defaultPidStatusProbe(info.pid) !== "dead") return;
-	// Delete only the stale owner's token-named file; a fresh lock uses a different file name.
-	await fs.rm(path.join(lockPath, lockFile), { force: true });
-	await removeEmptyLockDir(lockPath);
-}
-
-async function releaseLeaseMutationLock(lockPath: string, token: string): Promise<void> {
-	await fs.rm(leaseMutationLockFile(lockPath, token), { force: true });
-	await removeEmptyLockDir(lockPath);
-}
-
-async function acquireLeaseMutationLock(root: string, sessionId: string): Promise<() => Promise<void>> {
-	const lockPath = leaseMutationLockPath(root, sessionId);
-	await fs.mkdir(path.dirname(lockPath), { recursive: true });
-	for (let attempt = 0; attempt < LEASE_LOCK_RETRIES; attempt++) {
-		const token = randomBytes(16).toString("hex");
-		const info: LeaseLockInfo = { pid: process.pid, token };
-		if (await createLeaseMutationLock(lockPath, info)) return () => releaseLeaseMutationLock(lockPath, token);
-		await recoverStaleLeaseMutationLock(lockPath);
-		await Bun.sleep(LEASE_LOCK_RETRY_DELAY_MS);
-	}
-	throw new LeaseError(`lease_lock_timeout:${sessionId}`, "lease_lock_timeout");
-}
-
-async function withLeaseMutationLock<T>(root: string, sessionId: string, fn: () => Promise<T>): Promise<T> {
-	const release = await acquireLeaseMutationLock(root, sessionId);
-	try {
-		return await fn();
-	} finally {
-		await release();
-	}
 }
 
 export async function readLease(root: string, sessionId: string): Promise<SessionLease | null> {