@gajae-code/coding-agent 0.5.1 → 0.5.3

package/src/config/file-lock.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs/promises";
-import { isEnoent } from "@gajae-code/utils";
+import { isEnoent } from "@gajae-code/utils/fs-error";
 
 export interface FileLockOptions {
 	staleMs?: number;
@@ -45,29 +45,79 @@ export async function readFileLockInfoForGc(lockDir: string): Promise<{ pid: num
 	return info;
 }
 
-/** @internal */
-export async function removeFileLockDirForGc(lockDir: string): Promise<void> {
+/** Owner identity stamped into a `<file>.lock/info` record. */
+export interface FileLockOwnerToken {
+	pid: number;
+	timestamp: number;
+}
+
+/** Outcome of a guarded GC removal attempt (`removeFileLockDirForGc`). */
+export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
+
+/**
+ * @internal
+ * Fail-closed removal of a dead lock dir for GC. Re-reads the on-disk owner
+ * token as close to the unlink as possible and only deletes the dir when it
+ * STILL holds the exact `{pid, timestamp}` identity the caller observed dead.
+ *
+ * Closes the prune-time TOCTOU window (#606): between GC's dead re-read/probe
+ * and the unlink, a live process can reclaim a stale lock at the same path
+ * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
+ * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
+ * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a
+ * fresh acquirer between `mkdir` and `writeLockInfo`) refuses the delete and
+ * leaves the dir intact. POSIX has no atomic compare-and-delete for a
+ * directory, so the residual read->unlink window cannot be fully eliminated,
+ * but the reclaim-after-stale scenario the issue describes is now guarded.
+ */
+export async function removeFileLockDirForGc(
+	lockDir: string,
+	expected: FileLockOwnerToken,
+): Promise<FileLockGcRemoval> {
+	const current = await readLockInfo(lockDir);
+	if (!current) return "missing";
+	if (current.pid !== expected.pid || current.timestamp !== expected.timestamp) {
+		return "owner_changed";
+	}
 	await fs.rm(lockDir, { recursive: true, force: true });
+	return "removed";
 }
 
-function isProcessAlive(pid: number): boolean {
+type OwnerLiveness = "alive" | "dead" | "unknown";
+
+function ownerLiveness(pid: number): OwnerLiveness {
+	if (!Number.isFinite(pid) || pid <= 0) return "unknown";
 	try {
 		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
+		return "alive";
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ESRCH") return "dead";
+		// EPERM means the process exists but we may not signal it; treat as alive.
+		// Anything else is indeterminate.
+		return code === "EPERM" ? "alive" : "unknown";
 	}
 }
 
 async function isLockStale(lockPath: string, staleMs: number): Promise<boolean> {
 	const info = await readLockInfo(lockPath);
-	if (!info) return true;
-
-	if (!isProcessAlive(info.pid)) return true;
-
-	if (Date.now() - info.timestamp > staleMs) return true;
+	if (!info) {
+		try {
+			const stats = await fs.stat(lockPath);
+			return Date.now() - stats.mtimeMs > staleMs;
+		} catch (err) {
+			if (isEnoent(err)) return false;
+			throw err;
+		}
+	}
 
-	return false;
+	// Never reap a live owner by elapsed time: a long legitimate critical section must
+	// not have its lock stolen (#652). Reclaim a dead owner immediately. Only when owner
+	// liveness is indeterminate do we fall back to the staleMs elapsed-time heuristic.
+	const liveness = ownerLiveness(info.pid);
+	if (liveness === "dead") return true;
+	if (liveness === "alive") return false;
+	return Date.now() - info.timestamp > staleMs;
 }
 
 async function tryAcquireLock(lockPath: string): Promise<boolean> {

package/src/config/model-profile-activation.ts

@@ -11,6 +11,8 @@ import { type GjcModelAssignmentTargetId, isAuthenticated, type ModelRegistry }
 import { resolveModelRoleValue } from "./model-resolver";
 import type { Settings } from "./settings";
 
+const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
+
 type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel" | "sessionId"> & {
 	setModelTemporary?: AgentSession["setModelTemporary"];
 	setActiveModelProfile?: (name: string | undefined) => void;
@@ -51,12 +53,22 @@ export function formatModelProfileCredentialError(profileName: string, providers
 	return `Model profile "${profileName}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
 
+function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
+	// A retired-name alias is fallback-only: never shadow a profile that actually
+	// exists under the requested name (e.g. a user-defined `codex-standard`).
+	if (profiles.has(profileName)) return profileName;
+	const replacement = LEGACY_MODEL_PROFILE_ALIASES.get(profileName);
+	return replacement && profiles.has(replacement) ? replacement : profileName;
+}
+
 export async function prepareModelProfileActivation(
 	options: PrepareModelProfileActivationOptions,
 ): Promise<PreparedModelProfileActivation> {
-	const profile = options.modelRegistry.getModelProfile(options.profileName);
+	const profiles = options.modelRegistry.getModelProfiles();
+	const profileName = resolveModelProfileName(options.profileName, profiles);
+	const profile = profiles.get(profileName) ?? options.modelRegistry.getModelProfile(profileName);
 	if (!profile) {
-		const available = formatAvailableProfileNames(options.modelRegistry.getModelProfiles());
+		const available = formatAvailableProfileNames(profiles);
 		throw new Error(`Unknown model profile "${options.profileName}". Available profiles: ${available}`);
 	}
 
@@ -101,7 +113,7 @@ export async function prepareModelProfileActivation(
 	}
 
 	return {
-		profileName: options.profileName,
+		profileName,
 		session: options.session as PreparedModelProfileActivation["session"],
 		settings: options.settings as PreparedModelProfileActivation["settings"],
 		previousModel: options.session.model,

package/src/config/model-profiles.ts

@@ -202,25 +202,25 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "cursor/composer-1.5:xhigh",
 	}),
 	profile("minimax-eco", ["minimax-code"], {
-		default: "minimax-code/minimax-v3:low",
-		executor: "minimax-code/minimax-v3:minimal",
-		planner: "minimax-code/minimax-v3:low",
-		critic: "minimax-code/minimax-v3:medium",
-		architect: "minimax-code/minimax-v3:high",
+		default: "minimax-code/minimax-m3:low",
+		executor: "minimax-code/minimax-m3:minimal",
+		planner: "minimax-code/minimax-m3:low",
+		critic: "minimax-code/minimax-m3:medium",
+		architect: "minimax-code/minimax-m3:high",
 	}),
 	profile("minimax-medium", ["minimax-code"], {
-		default: "minimax-code/minimax-v3:medium",
-		executor: "minimax-code/minimax-v3:low",
-		planner: "minimax-code/minimax-v3:medium",
-		critic: "minimax-code/minimax-v3:high",
-		architect: "minimax-code/minimax-v3:xhigh",
+		default: "minimax-code/minimax-m3:medium",
+		executor: "minimax-code/minimax-m3:low",
+		planner: "minimax-code/minimax-m3:medium",
+		critic: "minimax-code/minimax-m3:high",
+		architect: "minimax-code/minimax-m3:xhigh",
 	}),
 	profile("minimax-pro", ["minimax-code"], {
-		default: "minimax-code/minimax-v3:xhigh",
-		executor: "minimax-code/minimax-v3:medium",
-		planner: "minimax-code/minimax-v3:high",
-		critic: "minimax-code/minimax-v3:xhigh",
-		architect: "minimax-code/minimax-v3:xhigh",
+		default: "minimax-code/minimax-m3:xhigh",
+		executor: "minimax-code/minimax-m3:medium",
+		planner: "minimax-code/minimax-m3:high",
+		critic: "minimax-code/minimax-m3:xhigh",
+		architect: "minimax-code/minimax-m3:xhigh",
 	}),
 	profile("opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-opus-4-8:xhigh",

package/src/config/model-registry.ts

@@ -35,6 +35,7 @@ import { $pickenv, isRecord, logger } from "@gajae-code/utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
+import type { ActiveSearchModelContext, WebSearchMode } from "../web/search/types";
 import { type ConfigError, ConfigFile } from "./config-file";
 import {
 	buildCanonicalModelIndex,
@@ -910,7 +911,7 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 	const output = resolvedModel.output ?? reference?.output;
 	return enrichModelThinking({
 		id: resolvedModel.id,
-		name: resolvedModel.name ?? (options.useDefaults ? resolvedModel.id : undefined),
+		name: resolvedModel.name ?? reference?.name ?? (options.useDefaults ? resolvedModel.id : undefined),
 		api: resolvedModel.api,
 		provider: resolvedModel.provider,
 		baseUrl: resolvedModel.baseUrl,
@@ -964,6 +965,7 @@ export class ModelRegistry {
 	#models: Model<Api>[] = [];
 	#canonicalIndex: CanonicalModelIndex = { records: [], byId: new Map(), bySelector: new Map() };
 	#customProviderApiKeys: Map<string, string> = new Map();
+	#providerWebSearchModes: Map<string, WebSearchMode> = new Map();
 	#keylessProviders: Set<string> = new Set();
 	#discoverableProviders: DiscoveryProviderConfig[] = [];
 	#customModelOverlays: CustomModelOverlay[] = [];
@@ -1073,6 +1075,7 @@ export class ModelRegistry {
 		}
 		this.#modelsConfigFile.invalidate();
 		this.#customProviderApiKeys.clear();
+		this.#providerWebSearchModes.clear();
 		this.#keylessProviders.clear();
 		this.#discoverableProviders = [];
 		// Drop config-sourced apiKeys from AuthStorage before reload; entries
@@ -1390,6 +1393,7 @@ export class ModelRegistry {
 		const configuredProviders = new Set(Object.keys(value.providers ?? {}));
 
 		for (const [providerName, providerConfig] of providerEntries) {
+			if (providerConfig.webSearch) this.#providerWebSearchModes.set(providerName, providerConfig.webSearch);
 			const providerApiKeyConfig = providerConfig.apiKey ?? resolveApiKeyEnvConfig(providerConfig.apiKeyEnv);
 			// Always set overrides when baseUrl/headers/apiKey/authHeader/compat/disableStrictTools/transport are present
 			if (
@@ -2441,6 +2445,22 @@ export class ModelRegistry {
 		);
 	}
 
+	getProviderWebSearchMode(provider: string): WebSearchMode | undefined {
+		return this.#providerWebSearchModes.get(provider);
+	}
+
+	getActiveSearchModelContext(model: Model<Api>): ActiveSearchModelContext {
+		return {
+			provider: model.provider,
+			modelId: model.id,
+			wireModelId: model.wireModelId,
+			api: model.api,
+			baseUrl: model.baseUrl,
+			headers: model.headers,
+			webSearch: this.getProviderWebSearchMode(model.provider),
+		};
+	}
+
 	/**
 	 * Get API key for a model.
 	 */

package/src/config/models-config-schema.ts

@@ -218,6 +218,7 @@ const ProviderConfigSchema = z
 			.optional(),
 		headers: z.record(z.string(), z.string()).optional(),
 		compat: OpenAICompatSchema.optional(),
+		webSearch: z.enum(["on", "off", "auto"]).optional(),
 		authHeader: z.boolean().optional(),
 		auth: ProviderAuthSchema.optional(),
 		discovery: ProviderDiscoverySchema.optional(),

package/src/config/settings-schema.ts

@@ -2,6 +2,7 @@ import type { Effort } from "@gajae-code/ai/model-thinking";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking-metadata";
 import { EDIT_MODES } from "../utils/edit-mode";
+import { CONFIGURABLE_SEARCH_PROVIDER_IDS } from "../web/search/types";
 
 const THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as readonly Effort[];
 
@@ -164,6 +165,7 @@ interface EnumDef<T extends readonly string[]> {
 interface ArrayDef<T> {
 	type: "array";
 	default: T[];
+	items?: { enum: readonly string[] };
 	ui?: UiBase;
 }
 
@@ -832,6 +834,55 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.serviceTier": {
+		type: "enum",
+		values: [
+			"inherit",
+			"none",
+			"auto",
+			"default",
+			"flex",
+			"scale",
+			"priority",
+			"openai-only",
+			"claude-only",
+		] as const,
+		default: "inherit",
+		ui: {
+			tab: "tasks",
+			label: "Subagent Service Tier",
+			description:
+				'Service tier applied to task-tool subagents only. "inherit" copies the main session tier; any explicit value overrides it for subagents without touching the main session.',
+			options: [
+				{
+					value: "inherit",
+					label: "Inherit",
+					description: "Use the main session's service tier (default)",
+				},
+				{ value: "none", label: "None", description: "Omit service_tier for subagents" },
+				{ value: "auto", label: "Auto", description: "Use provider default tier selection (OpenAI)" },
+				{ value: "default", label: "Default", description: "Standard priority processing (OpenAI)" },
+				{ value: "flex", label: "Flex", description: "Flexible capacity tier when available (OpenAI)" },
+				{ value: "scale", label: "Scale", description: "Scale Tier credits when available (OpenAI)" },
+				{
+					value: "priority",
+					label: "Priority",
+					description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)",
+				},
+				{
+					value: "openai-only",
+					label: "Priority (OpenAI only)",
+					description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
+				},
+				{
+					value: "claude-only",
+					label: "Priority (Claude only)",
+					description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)",
+				},
+			],
+		},
+	},
+
 	// Retries
 	"retry.enabled": { type: "boolean", default: true },
 
@@ -2068,6 +2119,17 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "Web Search", description: "Enable the web_search tool for web searching" },
 	},
 
+	"web_search.fallback": {
+		type: "array",
+		default: EMPTY_STRING_ARRAY,
+		items: { enum: CONFIGURABLE_SEARCH_PROVIDER_IDS },
+		ui: {
+			tab: "tools",
+			label: "Web Search Fallback",
+			description: "Ordered fallback web search providers after the active model native provider",
+		},
+	},
+
 	"browser.enabled": {
 		type: "boolean",
 		default: true,

package/src/dap/client.ts

@@ -1,6 +1,9 @@
-import { logger, ptree } from "@gajae-code/utils";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import { logger } from "@gajae-code/utils";
 import { formatCrashDiagnosticNotice, writeCrashReport } from "../debug/crash-diagnostics";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
+import { type OwnedProcess, spawnOwnedProcess } from "../runtime/process-lifecycle";
 import { ToolAbortError } from "../tools/tool-errors";
 import type {
 	DapCapabilities,
@@ -69,10 +72,21 @@ function toErrorMessage(value: unknown): string {
 	return String(value);
 }
 
+async function drainReadable(readable: ReadableStream<Uint8Array>): Promise<void> {
+	const reader = readable.getReader();
+	try {
+		while (!(await reader.read()).done) {}
+	} catch {
+		/* drain best-effort */
+	} finally {
+		reader.releaseLock();
+	}
+}
 export class DapClient {
 	readonly adapter: DapResolvedAdapter;
 	readonly cwd: string;
 	readonly proc: DapClientState["proc"];
+	readonly #owner: OwnedProcess;
 	/** ReadableStream of DAP bytes — from proc.stdout (stdio) or a socket (socket mode). */
 	readonly #readable: ReadableStream<Uint8Array>;
 	/** Write sink — proc.stdin (stdio) or a socket (socket mode). */
@@ -93,14 +107,15 @@ export class DapClient {
 	constructor(
 		adapter: DapResolvedAdapter,
 		cwd: string,
-		proc: DapClientState["proc"],
+		owner: OwnedProcess,
 		options?: { readable?: ReadableStream<Uint8Array>; writeSink?: DapWriteSink; socket?: { end(): void } },
 	) {
 		this.adapter = adapter;
 		this.cwd = cwd;
-		this.proc = proc;
-		this.#readable = options?.readable ?? (proc.stdout as ReadableStream<Uint8Array>);
-		this.#writeSink = options?.writeSink ?? proc.stdin;
+		this.proc = owner.child as DapClientState["proc"];
+		this.#owner = owner;
+		this.#readable = options?.readable ?? (this.proc.stdout as ReadableStream<Uint8Array>);
+		this.#writeSink = options?.writeSink ?? this.proc.stdin;
 		this.#socket = options?.socket;
 	}
 
@@ -116,13 +131,14 @@ export class DapClient {
 			...Bun.env,
 			...NON_INTERACTIVE_ENV,
 		};
-		const proc = ptree.spawn([adapter.resolvedCommand, ...adapter.args], {
+		const owner = spawnOwnedProcess([adapter.resolvedCommand, ...adapter.args], {
 			cwd,
 			stdin: "pipe",
 			env,
-			detached: true,
+			name: `dap:${adapter.name}`,
 		});
-		const client = new DapClient(adapter, cwd, proc);
+		const client = new DapClient(adapter, cwd, owner);
+		const proc = owner.child as DapClientState["proc"];
 		proc.exited.then(() => {
 			client.#handleProcessExit();
 		});
@@ -159,32 +175,40 @@ export class DapClient {
 		env: Record<string, string | undefined>;
 	}): Promise<DapClient> {
 		const socketPath = `/tmp/dap-${adapter.name}-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`;
-		const proc = ptree.spawn([adapter.resolvedCommand, ...adapter.args, `--listen=unix:${socketPath}`], {
+		const owner = spawnOwnedProcess([adapter.resolvedCommand, ...adapter.args, `--listen=unix:${socketPath}`], {
 			cwd,
 			stdin: "pipe",
 			env,
-			detached: true,
+			name: `dap:${adapter.name}:unix-socket`,
 		});
+		const proc = owner.child as DapClientState["proc"];
+		void drainReadable(proc.stdout);
+		let transport: SocketTransport | undefined;
 
-		// Wait for the socket file to appear (dlv needs to start listening)
-		await waitForCondition(
-			() => {
-				try {
-					Bun.file(socketPath).size;
-					return true;
-				} catch {
-					return false;
-				}
-			},
-			10_000,
-			proc,
-		);
+		try {
+			// Wait for the socket file to appear (dlv needs to start listening)
+			await waitForCondition(
+				// `Bun.file(path).size` returns 0 for a missing file instead of
+				// throwing, so it can't gate socket readiness. Use an existence
+				// check so the adapter has actually created the listener socket.
+				() => existsSync(socketPath),
+				10_000,
+				proc,
+			);
 
-		const { readable, writeSink, socket } = await connectSocket({ unix: socketPath });
-		const client = new DapClient(adapter, cwd, proc, { readable, writeSink, socket });
-		proc.exited.then(() => client.#handleProcessExit());
-		void client.#startMessageReader();
-		return client;
+			transport = await connectSocket({ unix: socketPath }, 10_000);
+			const client = new DapClient(adapter, cwd, owner, transport);
+			proc.exited.then(() => client.#handleProcessExit());
+			void client.#startMessageReader();
+			return client;
+		} catch (err) {
+			transport?.socket.end();
+			await owner.dispose();
+			await owner.awaitExit({ timeoutMs: 1_000 });
+			throw err;
+		} finally {
+			await fs.unlink(socketPath).catch(() => undefined);
+		}
 	}
 
 	/** macOS/other: listen on a random TCP port, spawn adapter with --client-addr, accept connection. */
@@ -214,12 +238,14 @@ export class DapClient {
 		});
 
 		const port = server.port;
-		const proc = ptree.spawn([adapter.resolvedCommand, ...adapter.args, `--client-addr=127.0.0.1:${port}`], {
+		const owner = spawnOwnedProcess([adapter.resolvedCommand, ...adapter.args, `--client-addr=127.0.0.1:${port}`], {
 			cwd,
 			stdin: "pipe",
 			env,
-			detached: true,
+			name: `dap:${adapter.name}:client-addr`,
 		});
+		const proc = owner.child as DapClientState["proc"];
+		void drainReadable(proc.stdout);
 
 		// Wait for dlv to connect (with timeout)
 		let rawSocket: Bun.Socket<undefined>;
@@ -230,13 +256,17 @@ export class DapClient {
 		);
 		try {
 			rawSocket = await Promise.race([connPromise, timeoutPromise]);
+		} catch (err) {
+			await owner.dispose();
+			await owner.awaitExit({ timeoutMs: 1_000 });
+			throw err;
 		} finally {
 			clearTimeout(connectTimeout);
 			server.stop();
 		}
 
 		const { readable, writeSink, socket } = wrapBunSocket(rawSocket);
-		const client = new DapClient(adapter, cwd, proc, { readable, writeSink, socket });
+		const client = new DapClient(adapter, cwd, owner, { readable, writeSink, socket });
 		proc.exited.then(() => client.#handleProcessExit());
 		void client.#startMessageReader();
 		return client;
@@ -414,14 +444,14 @@ export class DapClient {
 			/* socket may already be closed */
 		}
 		try {
-			this.proc.kill();
+			await this.#owner.dispose();
+			await this.#owner.awaitExit({ timeoutMs: 1_000 });
 		} catch (error) {
-			logger.debug("Failed to kill DAP adapter", {
+			logger.debug("Failed to dispose DAP adapter", {
 				adapter: this.adapter.name,
 				error: toErrorMessage(error),
 			});
 		}
-		await this.proc.exited.catch(() => {});
 	}
 
 	async #startMessageReader(): Promise<void> {
@@ -604,8 +634,8 @@ function socketToSink(socket: Bun.Socket<undefined>): DapWriteSink {
 }
 
 /** Connect to a unix domain socket and return DAP transport streams. */
-async function connectSocket(options: { unix: string }): Promise<SocketTransport> {
-	const { promise, resolve } = Promise.withResolvers<SocketTransport>();
+async function connectSocket(options: { unix: string }, timeoutMs = 10_000): Promise<SocketTransport> {
+	const { promise, resolve, reject } = Promise.withResolvers<SocketTransport>();
 	let streamController: ReadableStreamDefaultController<Uint8Array>;
 
 	const readable = new ReadableStream<Uint8Array>({
@@ -614,35 +644,46 @@ async function connectSocket(options: { unix: string }): Promise<SocketTransport
 		},
 	});
 
-	Bun.connect({
-		unix: options.unix,
-		socket: {
-			open(socket) {
-				resolve({
-					readable,
-					writeSink: socketToSink(socket),
-					socket,
-				});
-			},
-			data(_socket, data) {
-				streamController.enqueue(new Uint8Array(data));
-			},
-			close() {
-				try {
-					streamController.close();
-				} catch {
-					/* already closed */
-				}
-			},
-			error(_socket, err) {
-				try {
-					streamController.error(err);
-				} catch {
-					/* already closed */
-				}
+	const timeout = setTimeout(() => reject(new Error(`Socket connect timed out after ${timeoutMs}ms`)), timeoutMs);
+	let settled = false;
+	const settle = (fn: () => void) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timeout);
+		fn();
+	};
+	try {
+		const socketPromise = Bun.connect({
+			unix: options.unix,
+			socket: {
+				open(socket) {
+					settle(() =>
+						resolve({
+							readable,
+							writeSink: socketToSink(socket),
+							socket,
+						}),
+					);
+				},
+				data(_socket, data) {
+					streamController.enqueue(new Uint8Array(data));
+				},
+				close() {
+					try {
+						streamController.close();
+					} catch {
+						/* already closed */
+					}
+				},
+				error(_socket, err) {
+					settle(() => reject(err));
+				},
 			},
-		},
-	});
+		});
+		void socketPromise.catch(err => settle(() => reject(err)));
+	} catch (err) {
+		settle(() => reject(err));
+	}
 
 	return promise;
 }