@porte/cli 0.1.0

package/dist/run-cli-DB73XVhH.js

@@ -0,0 +1,4200 @@
+import { $ as INTERNAL_SERVER_ERROR, A as ProblemDetailsSchema, B as PermissionNotFoundError, C as DeviceTokenErrorSchema, D as PORTE_CLI_CLIENT_ID, E as PAIRING_CODE_PATH, F as AgentUnresponsiveError, G as makeConversationSummary, H as ConversationEventSchema, I as ConfigurationNotFoundError, J as IsoDateTimeSchema, K as ConversationIdSchema, L as ConversationBusyError, M as isClassifiedError, N as isDomainError, O as createLogger, P as WorkspaceNotAllowedError, Q as turnIdFor, R as ConversationNotFoundError, S as DeviceCodeResponseSchema, T as DeviceTokenResponseSchema, U as ToolViewSchema, V as TurnNotFoundError, W as ConversationCursorSchema, X as PermissionIdSchema, Y as MessageIdSchema, Z as ToolCallIdSchema, _ as readJsonRpcIncoming, _t as url, a as HOST_APPLICATION_ERROR_CODE, at as _enum, b as DEVICE_CODE_GRANT_TYPE, c as HOST_CONVERSATION_SUBPROTOCOL, ct as email, d as JSON_RPC_ERROR_CODES, dt as literal, et as InternalServerError, f as JsonRpcReadError, ft as number, g as jsonRpcNotification, gt as unknown, h as jsonRpcError, ht as string, i as HostControlMethods, it as h, j as HostPlatformSchema, l as HostRequestIdSchema, lt as httpUrl, m as handleJsonRpcRequest, mt as record, n as sendJsonRpcFrame, nt as CODING_AGENT_UNAVAILABLE_ERROR, o as HOST_APPLICATION_ERROR_MESSAGE, ot as array, p as JsonRpcTextSchema, pt as object, q as ElicitationIdSchema, r as HostConversationMethods, rt as CodingAgentUnavailableError, s as HOST_CONTROL_SUBPROTOCOL, st as discriminatedUnion, t as JsonRpcSendError, tt as ServiceUnavailableError, u as SequenceNumberSchema, ut as json, v as readJsonRpcTextFrame, w as DeviceTokenRequestSchema, x as DeviceCodeRequestSchema, y as formatPairingCode, z as ElicitationNotFoundError } from "./client-CpzDWkFF.js";
+import { homedir, hostname } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { createColors } from "picocolors";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createFetch, createSchema } from "@better-fetch/fetch";
+import { parseArgs } from "node:util";
+import { existsSync } from "node:fs";
+import * as acp from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+import { addAbortListener, once } from "node:events";
+import { Readable, Writable } from "node:stream";
+import { WebSocket } from "partysocket";
+import { WebSocket as WebSocket$1 } from "ws";
+//#region src/application/errors/pairing-errors.ts
+/** The Host cannot start until this machine has a stored credential. */
+var HostNotPairedError = class extends h("HostNotPairedError") {
+	constructor() {
+		super({
+			message: "Not paired yet. Run `porte pair` first.",
+			classification: "terminal"
+		});
+	}
+};
+/** An active pairing attempt did not produce a credential. */
+var PairingError = class extends h("PairingError") {
+	constructor(args) {
+		super({
+			cause: args.cause,
+			reason: args.reason,
+			message: MESSAGES[args.reason],
+			classification: CLASSIFICATIONS[args.reason]
+		});
+	}
+};
+const MESSAGES = {
+	denied: "Pairing was cancelled in the browser. Run porte pair again to retry.",
+	expired: "The code expired before anyone approved it. Run porte pair for a new one.",
+	unreachable: "Could not reach Porte. Check the connection, then run porte pair again.",
+	unexpected: "Porte returned an unexpected response."
+};
+const CLASSIFICATIONS = {
+	denied: "terminal",
+	expired: "terminal",
+	unreachable: "transient",
+	unexpected: "terminal"
+};
+//#endregion
+//#region src/application/ports/credential-store.ts
+/** The credential file could not be read, written, or removed. */
+var CredentialStoreError = class extends h("CredentialStoreError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "could not access the stored Porte credential",
+			classification: "terminal"
+		});
+	}
+};
+//#endregion
+//#region src/infrastructure/config/host-config.ts
+/** The process configuration contains a value the Host cannot use. */
+var ConfigError = class extends h("ConfigError") {
+	constructor(args) {
+		super({
+			...args,
+			classification: "terminal"
+		});
+	}
+};
+const DEFAULT_BASE_URL = "https://useporte.dev";
+const ConfigSchema = object({
+	baseUrl: url({
+		protocol: /^https?$/,
+		error: "PORTE_URL must be an http or https origin, such as https://useporte.dev"
+	}),
+	dataDirectory: string().min(1, { error: "PORTE_DATA_DIRECTORY must not be empty" })
+});
+/** Read and validate the Host process configuration. */
+function loadConfig(env) {
+	const parsed = ConfigSchema.safeParse({
+		baseUrl: env.PORTE_URL ?? DEFAULT_BASE_URL,
+		dataDirectory: env.PORTE_DATA_DIRECTORY ?? join(homedir(), ".porte")
+	});
+	if (parsed.success) return parsed.data;
+	throw new ConfigError({ message: parsed.error.issues.map((issue) => `  ${issue.message}`).join("\n") });
+}
+//#endregion
+//#region src/infrastructure/node/machine.ts
+/** The Host does not support the current operating system. */
+var UnsupportedPlatformError = class extends h("UnsupportedPlatformError") {
+	constructor(platform) {
+		super({
+			message: `Porte does not run on ${platform} yet.`,
+			classification: "terminal"
+		});
+	}
+};
+/**
+* What this Mac calls itself.
+*
+* `platform` stays the runtime's own token, so what is stored is what Node
+* reported. Turning `darwin` into `macOS` is the reader's job, and spelling it
+* both ways would leave two versions of one fact.
+*/
+function describeThisMachine() {
+	const platform = HostPlatformSchema.safeParse(process.platform);
+	if (!platform.success) throw new UnsupportedPlatformError(process.platform);
+	return {
+		name: machineName(),
+		platform: platform.data
+	};
+}
+/**
+* The name the person gave this machine, not the one the network uses.
+*
+* macOS keeps both: `Alexander's MacBook Pro` in settings, and a hyphenated
+* `.local` form for mDNS. The settings name is the one they will recognise on
+* the confirmation screen, so it is worth asking for.
+*/
+function machineName() {
+	return (process.platform === "darwin" ? computerName() : null) ?? hostname().replace(/\.local$/, "");
+}
+/** Null on any refusal: a machine name is never worth failing pairing over. */
+function computerName() {
+	try {
+		const name = execFileSync("scutil", ["--get", "ComputerName"], {
+			encoding: "utf8",
+			timeout: 1e3
+		}).trim();
+		return name.length > 0 ? name : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/infrastructure/websocket/websocket-errors.ts
+/** The HTTP upgrade for this WebSocket was refused. */
+var WebSocketHandshakeRefused = class extends h("WebSocketHandshakeRefused") {
+	constructor(args) {
+		super({
+			...args,
+			message: `WebSocket handshake refused (HTTP ${String(args.status)})`,
+			classification: "terminal"
+		});
+	}
+};
+/** The peer closed with an RFC 6455 terminal close code (1002, 1003, 1007, 1008, 1009). */
+var WebSocketProtocolClose = class extends h("WebSocketProtocolClose") {
+	constructor(args) {
+		super({
+			...args,
+			classification: "terminal"
+		});
+	}
+};
+/** Inbound frame handling failed, so this connection stopped. */
+var WebSocketHandlerError = class extends h("WebSocketHandlerError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "WebSocket frame handler failed",
+			classification: "unknown"
+		});
+	}
+};
+//#endregion
+//#region src/entrypoints/cli/version.ts
+/** Package version. Source is `package.json`. */
+const VERSION = "0.1.0";
+//#endregion
+//#region src/entrypoints/cli/cli-error.ts
+/** Bad arguments or missing required flags. */
+var UsageError = class extends h("UsageError") {
+	constructor(args) {
+		super({
+			...args,
+			classification: "terminal"
+		});
+	}
+};
+/** Test whether a caught value is an expected CLI error. */
+function isCliError(cause) {
+	return cause instanceof UsageError || cause instanceof ConfigError || cause instanceof UnsupportedPlatformError || cause instanceof HostNotPairedError || cause instanceof WebSocketHandlerError || cause instanceof JsonRpcSendError || cause instanceof WebSocketHandshakeRefused || cause instanceof WebSocketProtocolClose || cause instanceof PairingError || cause instanceof CredentialStoreError;
+}
+/** Map one CLI error to its process exit code. */
+function exitCodeFor(error) {
+	if (error instanceof UsageError) return 2;
+	if (error instanceof ConfigError) return 2;
+	if (error instanceof HostNotPairedError) return 2;
+	if (error instanceof WebSocketHandshakeRefused) return error.status === 401 || error.status === 403 ? 2 : 1;
+	return 1;
+}
+/** Format one safe error for standard error output. */
+function formatError(error) {
+	if (error instanceof UsageError) return error.message;
+	let body;
+	if (error instanceof ConfigError || error instanceof UnsupportedPlatformError) body = `Error (ECONFIG): Porte configuration is invalid.\n${error.message}`;
+	else if (error instanceof HostNotPairedError) body = error.message;
+	else if (error instanceof WebSocketHandlerError || error instanceof JsonRpcSendError) body = "Error (ERELAY): host connection stopped. Restart `porte up`.";
+	else if (error instanceof WebSocketHandshakeRefused) body = error.status === 401 || error.status === 403 ? `Error (EAUTH): ${error.message} Run \`porte pair\` to pair this Mac again.` : `Error (ERELAY): ${error.message}`;
+	else if (error instanceof WebSocketProtocolClose) body = `Error (ERELAY): ${error.message}`;
+	else if (error instanceof PairingError) body = `Error (EPAIR): ${error.message} Run \`porte pair\` to try again.`;
+	else body = `Error (ECRED): ${error.message}`;
+	return `porte v${VERSION} — ${body}`;
+}
+//#endregion
+//#region src/entrypoints/cli/output.ts
+/**
+* Everything the CLI writes for a person to read.
+*
+* Layout lives here rather than at the call sites, so blank lines and indents
+* stay consistent and a handler says what it means instead of counting spaces.
+* Machine-readable output never passes through this: it goes straight to stdout.
+*/
+/** Two spaces. Deep enough to group a line under its heading, shallow enough to scan. */
+const INDENT = "  ";
+/** Move the cursor to the start of the previous line. */
+const CURSOR_UP = "\x1B[1A";
+/** Clears everything from the cursor down, however many rows that turns out to be. */
+const CLEAR_BELOW = "\r\x1B[0J";
+/** Assumed width when a stream is not a terminal and reports none. */
+const FALLBACK_COLUMNS = 80;
+/**
+* Marks for one moment each, never decoration.
+*
+* Placement follows width, not habit. A single-width glyph can lead a line
+* because it shifts nothing after it; an emoji is double-width and would push
+* its text out of column, so emoji trail the line they mark instead.
+*/
+const EMOJI = {
+	pair: "🚪",
+	waiting: "⏳",
+	done: "✓",
+	failed: "✗",
+	warned: "!"
+};
+/**
+* Build the writer for one stream.
+*
+* Colour follows the stream rather than the process, because Porte prints JSON
+* on stdout and prose on stderr. A piped `porte list` must stay clean while the
+* messages beside it keep their colour.
+*
+* @param stream - The stream this writer writes to.
+*/
+function createOutput(stream) {
+	const c = createColors(isColorAllowed(stream));
+	const line = (text) => stream.write(`${text}\n`);
+	const terminal = "isTTY" in stream && stream.isTTY === true;
+	let statusRows = 0;
+	const endStatus = () => {
+		statusRows = 0;
+	};
+	return {
+		blank: () => stream.write("\n"),
+		title: (text, mark) => {
+			stream.write("\n");
+			line(mark === void 0 ? c.bold(text) : `${c.bold(text)}  ${mark}`);
+			stream.write("\n");
+		},
+		step: (position, text) => line(`${INDENT}${c.dim(`${String(position)}.`)} ${text}`),
+		note: (text) => line(`${INDENT}${c.dim(text)}`),
+		done: (text) => {
+			endStatus();
+			stream.write("\n");
+			line(`${c.green(EMOJI.done)} ${text}`);
+		},
+		failed: (text) => {
+			endStatus();
+			stream.write("\n");
+			line(`${c.red(EMOJI.failed)} ${text}`);
+		},
+		warned: (text) => {
+			endStatus();
+			line(`${EMOJI.warned} ${c.yellow(text)}`);
+		},
+		raw: (text) => line(text),
+		status: (text) => {
+			if (terminal && statusRows > 0) stream.write(`${CURSOR_UP.repeat(statusRows)}${CLEAR_BELOW}`);
+			line(text);
+			statusRows = terminal ? rowsUsed(text, terminalColumns(stream)) : 0;
+		},
+		prompt: (text) => stream.write(text),
+		rewrite: (above, prompt) => {
+			const columns = terminalColumns(stream);
+			const up = rowsUsed(above, columns) + rowsUsed(prompt, columns) - 1;
+			stream.write(`${CURSOR_UP.repeat(up)}${CLEAR_BELOW}${above}\n${prompt}`);
+		},
+		emphasis: {
+			code: (text) => c.bold(c.cyan(text)),
+			url: (text) => c.underline(c.cyan(text)),
+			quiet: (text) => c.dim(text),
+			strong: (text) => c.bold(text),
+			ok: (text) => c.green(text)
+		}
+	};
+}
+/** The pairing prompt, which is the one screen a new person always meets. */
+const PAIR_EMOJI = EMOJI.pair;
+const WAITING_EMOJI = EMOJI.waiting;
+/** Honour NO_COLOR, then fall back to whether a person is actually watching. */
+function isColorAllowed(stream) {
+	if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") return false;
+	if (process.env.FORCE_COLOR !== void 0 && process.env.FORCE_COLOR !== "") return true;
+	return "isTTY" in stream && stream.isTTY === true;
+}
+/** How many rows a line takes once the terminal wraps it. */
+function rowsUsed(text, columns) {
+	return Math.max(1, Math.ceil(visibleLength(text) / columns));
+}
+/** Colour codes occupy no columns, so they cannot count towards the width. */
+function visibleLength(text) {
+	return text.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+/** A terminal reports its width. A pipe reports none and wraps at nothing. */
+const widthSchema = object({ columns: number().int().positive() });
+function terminalColumns(stream) {
+	const parsed = widthSchema.safeParse(stream);
+	return parsed.success ? parsed.data.columns : FALLBACK_COLUMNS;
+}
+//#endregion
+//#region src/entrypoints/cli/cli-error-boundary.ts
+/** Write one expected CLI error and return its process exit code. */
+function reportCliError(stderr, error) {
+	const output = createOutput(stderr);
+	const body = formatError(error);
+	if (error._tag === "UsageError") output.raw(body);
+	else output.failed(body);
+	return exitCodeFor(error);
+}
+/** Write one unexpected CLI defect and return exit code 1. */
+function reportUnexpectedCliError(stderr, cause) {
+	const detail = cause instanceof Error ? cause.stack ?? cause.message : String(cause);
+	stderr.write(`porte v${VERSION} — unexpected error\n${detail}\n`);
+	stderr.write("Report: https://github.com/alexander-zuev/porte/issues/new\n");
+	return 1;
+}
+//#endregion
+//#region src/application/commands/pair-host.ts
+/**
+* Pair this Mac with a Porte account.
+*
+* The daemon asks for a code, shows it, and waits. Approval happens on the
+* person's phone, so this machine never handles a password and the credential
+* it ends up with belongs to whoever approved.
+*/
+async function pairHost(input) {
+	const grant = await input.authorizer.requestCode(input.host);
+	input.onPrompt({
+		userCode: grant.userCode,
+		verificationUri: grant.verificationUri,
+		expiresInSeconds: grant.expiresInSeconds
+	});
+	const answered = await waitForApproval(input, grant);
+	if (answered.status !== "paired") return answered;
+	await input.credentials.write({
+		baseUrl: input.baseUrl,
+		token: answered.token
+	});
+	return {
+		status: "paired",
+		account: await input.authorizer.accountOf(answered.token)
+	};
+}
+/**
+* Poll until the person answers or the code dies.
+*
+* The deadline is enforced here as well as by the server, so a server that
+* stops answering cannot leave the daemon polling forever.
+*/
+async function waitForApproval(input, grant) {
+	const deadline = input.now() + grant.expiresInSeconds * 1e3;
+	let intervalSeconds = grant.intervalSeconds;
+	while (input.now() < deadline) {
+		await input.sleep(intervalSeconds * 1e3);
+		const answer = await input.authorizer.poll(grant.deviceCode);
+		if (answer.status === "granted") return {
+			status: "paired",
+			token: answer.token
+		};
+		if (answer.status === "denied") return { status: "denied" };
+		if (answer.status === "expired") return { status: "expired" };
+		if (answer.status === "slow-down") intervalSeconds += answer.intervalSeconds;
+	}
+	return { status: "expired" };
+}
+//#endregion
+//#region src/infrastructure/persistence/credential-store.ts
+const StoredCredentialSchema = object({
+	baseUrl: url({ protocol: /^https?$/ }),
+	token: string().min(1)
+});
+/** Owner read and write only. This file is a bearer credential. */
+const FILE_MODE = 384;
+const DIRECTORY_MODE = 448;
+const FILE_NAME = "credentials.json";
+/**
+* The Porte credential as a file under the user's home directory.
+*
+* A file this process cannot parse is treated as absent rather than fatal, so a
+* corrupted credential sends the person to `porte pair` instead of to a stack
+* trace. Unreadable for any other reason still fails loudly.
+*/
+var FileCredentialStore = class {
+	filePath;
+	constructor(dataDirectory) {
+		this.filePath = join(dataDirectory, FILE_NAME);
+	}
+	async read() {
+		let contents;
+		try {
+			contents = await readFile(this.filePath, "utf8");
+		} catch (cause) {
+			if (isMissing(cause)) return null;
+			throw new CredentialStoreError({ cause });
+		}
+		return parseCredential(contents);
+	}
+	async write(credential) {
+		try {
+			await mkdir(dirname(this.filePath), {
+				recursive: true,
+				mode: DIRECTORY_MODE
+			});
+			await writeFile(this.filePath, JSON.stringify(credential, null, 2), {
+				encoding: "utf8",
+				mode: FILE_MODE
+			});
+		} catch (cause) {
+			throw new CredentialStoreError({ cause });
+		}
+	}
+	async clear() {
+		try {
+			await rm(this.filePath, { force: true });
+		} catch (cause) {
+			throw new CredentialStoreError({ cause });
+		}
+	}
+};
+function isMissing(cause) {
+	return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+/** Unparseable and invalid both mean "no usable credential", so both give null. */
+function parseCredential(contents) {
+	try {
+		const parsed = StoredCredentialSchema.safeParse(JSON.parse(contents));
+		return parsed.success ? parsed.data : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/infrastructure/porte/device-authorization-client.ts
+/** The token exchange stays the plugin's own endpoint, under its base path. */
+const DEVICE_TOKEN_PATH = "/api/auth/device/token";
+/** Better Auth's own route. The grant never says who approved. */
+const SESSION_PATH = "/api/auth/get-session";
+const sessionAccountSchema = object({ user: object({
+	email: email().nullish(),
+	name: string().nullish()
+}) });
+/**
+* The two calls the grant is made of, and the shapes each side may send.
+*
+* Declaring them once means a response is validated before it is a value, so
+* nothing below this file has to ask whether a field arrived.
+*/
+const grantSchema = createSchema({
+	[`@post${PAIRING_CODE_PATH}`]: {
+		input: DeviceCodeRequestSchema,
+		output: DeviceCodeResponseSchema
+	},
+	[`@post${DEVICE_TOKEN_PATH}`]: {
+		input: DeviceTokenRequestSchema,
+		output: DeviceTokenResponseSchema
+	}
+});
+/**
+* The device authorization grant over HTTP.
+*
+* Wire names stay snake_case until they leave this file, so the RFC and the
+* request bodies can be compared line for line.
+*/
+var DeviceAuthorizationClient = class {
+	baseUrl;
+	fetch;
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+		this.fetch = createFetch({
+			baseURL: baseUrl,
+			schema: grantSchema,
+			throw: false
+		});
+	}
+	async requestCode(host) {
+		const { data, error } = await this.fetch(`@post${PAIRING_CODE_PATH}`, {
+			body: {
+				client_id: PORTE_CLI_CLIENT_ID,
+				host_name: host.name,
+				host_platform: host.platform
+			},
+			errorSchema: ProblemDetailsSchema,
+			output: DeviceCodeResponseSchema
+		});
+		if (error) throw transportError(error);
+		return {
+			deviceCode: data.device_code,
+			userCode: data.user_code,
+			verificationUri: data.verification_uri,
+			intervalSeconds: data.interval,
+			expiresInSeconds: data.expires_in
+		};
+	}
+	/**
+	* Ask once whether the person has approved yet.
+	*
+	* Pending and slow-down arrive as non-2xx, so the status alone cannot decide
+	* this. The refusal code in the body is what separates waiting from failing.
+	*/
+	async poll(deviceCode) {
+		const { data, error } = await this.fetch(`@post${DEVICE_TOKEN_PATH}`, {
+			body: {
+				grant_type: DEVICE_CODE_GRANT_TYPE,
+				device_code: deviceCode,
+				client_id: PORTE_CLI_CLIENT_ID
+			},
+			output: DeviceTokenResponseSchema
+		});
+		if (data) return {
+			status: "granted",
+			token: data.access_token
+		};
+		const refusal = DeviceTokenErrorSchema.safeParse(error);
+		if (!refusal.success) throw transportError(error);
+		return fromRefusal(refusal.data.error);
+	}
+	/**
+	* End the pairing.
+	*
+	* Stubbed: the route it needs does not exist yet, so unpairing currently only
+	* clears the local credential. Wiring the request is a change to this method.
+	*/
+	revoke(_token) {
+		return Promise.resolve();
+	}
+	/**
+	* Ask who the new token belongs to.
+	*
+	* Better Auth's own route rather than the grant's, so it stays outside the
+	* schema above. A name is a courtesy, and pairing has already succeeded by
+	* the time anyone asks for it.
+	*/
+	async accountOf(token) {
+		try {
+			const response = await fetch(new URL(SESSION_PATH, this.baseUrl), { headers: { Authorization: `Bearer ${token}` } });
+			if (!response.ok) return null;
+			const parsed = sessionAccountSchema.safeParse(await response.json());
+			if (!parsed.success) return null;
+			return parsed.data.user.email ?? parsed.data.user.name ?? null;
+		} catch {
+			return null;
+		}
+	}
+};
+/** What the grant's own vocabulary means to the person who ran `porte pair`. */
+function fromRefusal(refusal) {
+	switch (refusal) {
+		case "authorization_pending": return { status: "pending" };
+		case "slow_down": return {
+			status: "slow-down",
+			intervalSeconds: 5
+		};
+		case "access_denied": return { status: "denied" };
+		case "expired_token": return { status: "expired" };
+		default: throw new PairingError({
+			reason: "unexpected",
+			cause: refusal
+		});
+	}
+}
+/** A zero status is better-fetch reporting it never reached the server. */
+function transportError(error) {
+	return new PairingError({
+		reason: error.status === 0 ? "unreachable" : "unexpected",
+		cause: error
+	});
+}
+//#endregion
+//#region src/infrastructure/bootstrap/pairing-resources.ts
+/** Create the resources used by one pairing command. */
+function createPairingResources(config) {
+	return {
+		credentials: new FileCredentialStore(config.dataDirectory),
+		authorizer: new DeviceAuthorizationClient(config.baseUrl)
+	};
+}
+//#endregion
+//#region src/infrastructure/node/clipboard.ts
+/** The clipboard tool for this platform, or null where we know of none. */
+function clipboardCommand() {
+	if (process.platform === "darwin") return ["pbcopy", []];
+	if (process.platform === "win32") return ["clip", []];
+	if (process.platform === "linux") return ["xclip", ["-selection", "clipboard"]];
+	return null;
+}
+/**
+* Put text on the system clipboard.
+*
+* Returns false when no clipboard tool is reachable, which includes a Linux box
+* without xclip installed. Copying is a convenience, so a missing tool must
+* leave the command it decorates working exactly as before.
+*/
+async function copyToClipboard(text) {
+	const command = clipboardCommand();
+	if (command === null) return false;
+	const [bin, args] = command;
+	return new Promise((resolve) => {
+		const child = spawn(bin, [...args]);
+		child.on("error", () => {
+			resolve(false);
+		});
+		child.on("close", (code) => {
+			resolve(code === 0);
+		});
+		child.stdin.end(text);
+	});
+}
+//#endregion
+//#region src/infrastructure/node/open-url.ts
+/** The browser launcher for this platform, or null where we know of none. */
+function openCommand() {
+	if (process.platform === "darwin") return ["open", []];
+	if (process.platform === "win32") return ["cmd", [
+		"/c",
+		"start",
+		""
+	]];
+	if (process.platform === "linux") return ["xdg-open", []];
+	return null;
+}
+/**
+* Hand a URL to the default browser.
+*
+* Detached and with its streams ignored, so the browser never holds the CLI
+* open and never writes over the prompt still on screen. Returns false when no
+* launcher exists, which leaves the printed URL as the way through.
+*/
+async function openUrl(url) {
+	const command = openCommand();
+	if (command === null) return false;
+	const [bin, args] = command;
+	return new Promise((resolve) => {
+		const child = spawn(bin, [...args, url], {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.on("error", () => {
+			resolve(false);
+		});
+		child.unref();
+		resolve(true);
+	});
+}
+//#endregion
+//#region src/infrastructure/terminal/key-press.ts
+/** End of text, which the terminal sends for Ctrl+C in raw mode. */
+const CTRL_C = "";
+/** Watch terminal key presses and return a function that stops the watch. */
+function onKey(handler) {
+	const input = process.stdin;
+	if (!input.isTTY) return () => void 0;
+	input.setRawMode(true);
+	input.resume();
+	input.setEncoding("utf8");
+	input.on("data", listener);
+	return stop;
+	function listener(chunk) {
+		if (chunk === CTRL_C) {
+			stop();
+			process.kill(process.pid, "SIGINT");
+			return;
+		}
+		handler(chunk);
+	}
+	function stop() {
+		input.off("data", listener);
+		input.setRawMode(false);
+		input.pause();
+	}
+}
+//#endregion
+//#region src/entrypoints/cli/pair-command.ts
+/** Pair this machine with one Porte account. */
+async function runPairCommand(input) {
+	const resources = createPairingResources(input.config);
+	const output = createOutput(input.stderr);
+	const { code, url, quiet, strong, ok } = output.emphasis;
+	const interactive = process.stdin.isTTY;
+	let stopWatching;
+	const paired = await pairHost({
+		authorizer: resources.authorizer,
+		credentials: resources.credentials,
+		baseUrl: input.config.baseUrl,
+		host: describeThisMachine(),
+		onPrompt: (prompt) => {
+			const shown = formatPairingCode(prompt.userCode);
+			const waiting = `Waiting for approval — the code expires in ${String(Math.round(prompt.expiresInSeconds / 60))} minutes.  ${WAITING_EMOJI}`;
+			output.title("Pair this Mac with Porte", PAIR_EMOJI);
+			if (!interactive) {
+				output.raw(`First copy your pairing code:  ${code(shown)}`);
+				output.raw(`Then open ${url(prompt.verificationUri)} in your browser.`);
+				output.blank();
+				output.raw(quiet(waiting));
+				return;
+			}
+			const codeLine = (hint) => `First copy your pairing code:  ${code(shown)}   ${hint}`;
+			const promptLine = `${strong("Press Enter")} to open ${url(prompt.verificationUri)} in your browser...`;
+			output.raw(codeLine(quiet("(press c to copy)")));
+			output.prompt(promptLine);
+			stopWatching = onKey((key) => {
+				if (key === "\r") {
+					stopWatching?.();
+					output.blank();
+					output.blank();
+					output.raw(quiet(waiting));
+					openUrl(prompt.verificationUri);
+					return;
+				}
+				if (key.toLowerCase() !== "c") return;
+				copyToClipboard(prompt.userCode).then((copied) => {
+					const hint = copied ? `${ok("✓")} ${quiet("copied")}` : quiet("✗ no clipboard");
+					output.rewrite(codeLine(hint), promptLine);
+				});
+			});
+		},
+		sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+		now: () => Date.now()
+	});
+	stopWatching?.();
+	if (paired.status === "denied") {
+		output.warned("Pairing was refused. Nothing was connected.");
+		output.note(`Run ${code("porte pair")} again to retry`);
+		return 1;
+	}
+	if (paired.status === "expired") {
+		output.warned("The code expired before anyone answered it.");
+		output.note(`Run ${code("porte pair")} for a new one`);
+		return 1;
+	}
+	const { account } = paired;
+	const machine = strong(describeThisMachine().name);
+	output.done(account === null ? `Paired ${machine} with Porte` : `Paired ${machine} with ${strong(account)} on Porte`);
+	output.blank();
+	output.raw(`  Run ${code("porte up")} to control this Mac's Grok conversations from anywhere`);
+	output.note("Expires in 7 days if it never connects");
+	return 0;
+}
+//#endregion
+//#region src/entrypoints/cli/parse-command.ts
+/** Root help text. */
+const HELP = `Usage:
+  porte <command> [options]
+
+Pair, unpair, or connect this host to Porte.
+
+Options:
+  -h, --help       Show help
+  -V, --version    Show version
+  -v, --verbose    Write debug logs to stderr
+
+Commands:
+  pair             Link this Mac to your Porte account
+  unpair           End this Mac's pairing
+  up               Connect this host to Porte
+
+Examples:
+  porte pair
+  porte up
+`;
+/** Help for `porte pair`. */
+const PAIR_HELP = `Usage:
+  porte pair
+
+Link this Mac to your Porte account. Prints a code to approve in any browser,
+then waits. Run this once; \`porte up\` uses what it stores.
+
+Options:
+  -h, --help        Show this help
+
+Environment:
+  PORTE_URL             Porte origin. Defaults to https://useporte.dev
+  PORTE_DATA_DIRECTORY  Host data directory. Defaults to ~/.porte
+`;
+/** Help for `porte unpair`. */
+const UNPAIR_HELP = `Usage:
+  porte unpair
+
+End this Mac's pairing. Porte stops accepting it, and the local credential is
+deleted. Run \`porte pair\` to connect it again.
+
+Options:
+  -h, --help        Show this help
+
+Environment:
+  PORTE_DATA_DIRECTORY  Host data directory. Defaults to ~/.porte
+`;
+/** Help for `porte up`. */
+const UP_HELP = `Usage:
+  porte up
+
+Connect this host to Porte and stay connected. Run \`porte pair\` first.
+
+Options:
+  -h, --help        Show this help
+  -v, --verbose     Write debug logs to stderr
+
+Environment:
+  PORTE_URL             Porte origin. Defaults to https://useporte.dev
+  PORTE_DATA_DIRECTORY  Host data directory. Defaults to ~/.porte
+`;
+/**
+* Parse POSIX flags and one subcommand.
+*
+* @param argv - Args after the binary name.
+*/
+function parseCommand(argv) {
+	let parsed;
+	try {
+		parsed = parseCommandArgs(argv);
+	} catch {
+		throw new UsageError({ message: HELP.trimEnd() });
+	}
+	const { values, positionals } = parsed;
+	if (values.help) {
+		const verb = positionals[0];
+		if (verb === "up") return {
+			kind: "help",
+			text: UP_HELP
+		};
+		if (verb === "pair") return {
+			kind: "help",
+			text: PAIR_HELP
+		};
+		if (verb === "unpair") return {
+			kind: "help",
+			text: UNPAIR_HELP
+		};
+		return {
+			kind: "help",
+			text: HELP
+		};
+	}
+	if (values.version) return { kind: "version" };
+	const verb = positionals[0];
+	if (verb === void 0) throw new UsageError({ message: HELP.trimEnd() });
+	if (verb === "up") {
+		if (positionals.length !== 1) throw new UsageError({ message: UP_HELP.trimEnd() });
+		return { kind: "up" };
+	}
+	if (verb === "pair") {
+		if (positionals.length !== 1) throw new UsageError({ message: PAIR_HELP.trimEnd() });
+		return { kind: "pair" };
+	}
+	if (verb === "unpair") {
+		if (positionals.length !== 1) throw new UsageError({ message: UNPAIR_HELP.trimEnd() });
+		return { kind: "unpair" };
+	}
+	throw new UsageError({ message: HELP.trimEnd() });
+}
+function parseCommandArgs(argv) {
+	return parseArgs({
+		args: [...argv],
+		options: {
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			},
+			version: {
+				type: "boolean",
+				short: "V",
+				default: false
+			},
+			verbose: {
+				type: "boolean",
+				short: "v",
+				default: false
+			}
+		},
+		allowPositionals: true,
+		strict: true
+	});
+}
+//#endregion
+//#region src/domain/messages/types.ts
+function createCommand(name, data) {
+	return {
+		type: "command",
+		name,
+		...data
+	};
+}
+function createEvent(name, data) {
+	return {
+		type: "event",
+		name,
+		...data
+	};
+}
+function createQuery(name, data) {
+	return {
+		type: "query",
+		name,
+		...data
+	};
+}
+//#endregion
+//#region src/application/host-runtime.ts
+/** Owns the active resources for one Host process. */
+var HostRuntime = class {
+	signal;
+	deps;
+	constructor(signal, deps) {
+		this.signal = signal;
+		this.deps = deps;
+	}
+	/** Open the control connection and wait for shutdown. */
+	async run(onStatus) {
+		if (this.signal.aborted) return;
+		try {
+			this.deps.connections.connectControl(onStatus);
+			await waitForStop(this.signal, this.deps.connections.controlStopped);
+		} finally {
+			await this.shutdown();
+		}
+	}
+	/** Close conversations and the agent, let in-flight turns settle, then drop the sockets. */
+	async shutdown() {
+		try {
+			await this.deps.bus.handle(createCommand("CloseAllConversations", {}));
+			await this.deps.background.drain();
+		} finally {
+			this.deps.connections.closeAll();
+		}
+	}
+};
+function waitForStop(signal, controlStopped) {
+	if (signal.aborted) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const stop = () => {
+			resolve();
+		};
+		signal.addEventListener("abort", stop, { once: true });
+		controlStopped.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", stop);
+		});
+	});
+}
+//#endregion
+//#region src/domain/messages/base.ts
+const isCommand = (message) => message.type === "command";
+const isEvent = (message) => message.type === "event";
+const isQuery = (message) => message.type === "query";
+h("HandlerNotImplementedError");
+/** A message reached the bus with no registered handler. Programmer defect. */
+var NoHandlerError = class extends h("NoHandlerError") {
+	constructor(args) {
+		super({
+			...args,
+			message: `No handler for ${args.kind} ${args.name}`,
+			classification: "terminal"
+		});
+	}
+};
+//#endregion
+//#region src/application/handlers/answer-elicitation.ts
+/** The `elicitation.resolved` event releases the parked agent request (see the registry). */
+const answerElicitation = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	conversation.answerElicitation(command.turnId, command.elicitationId, command.answer);
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/handlers/answer-permission.ts
+/** The `permission.resolved` event releases the parked agent request (see the registry). */
+const answerPermission = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	conversation.answerPermission(command.turnId, command.permissionId, command.optionId);
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/handlers/apply-agent-update.ts
+const logger$7 = createLogger("apply-agent-update");
+/**
+* Record what the agent streamed. Updates for a conversation already closed are
+* dropped, and so are turn-scoped events for a turn that is not running: after
+* a cancel deadline the agent may keep talking about a turn the Host finished.
+*/
+const applyAgentUpdate = async (command, deps) => {
+	const conversation = deps.conversations.find(command.conversationId);
+	if (conversation === null) return;
+	const turn = conversation.turn;
+	const events = command.events.filter((event) => {
+		if (!("turnId" in event)) return true;
+		return turn.state === "running" && turn.turnId === event.turnId;
+	});
+	if (events.length < command.events.length) logger$7.debug("late_agent_events_dropped", { details: {
+		conversationId: command.conversationId,
+		dropped: command.events.length - events.length
+	} });
+	if (events.length === 0) return;
+	conversation.applyAgentEvents(events);
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/turn-policy.ts
+/**
+* How long a cancelled prompt may keep running before the Host closes the
+* agent session and finishes the turn itself.
+*/
+const CANCEL_DEADLINE_MS = 15e3;
+/** How long a conversation may sit with no running turn before it leaves this process. */
+const IDLE_EVICTION_MS = 18e5;
+//#endregion
+//#region src/application/handlers/cancel-turn.ts
+/**
+* Cancel the running turn. A turn that already ended is a no-op: cancel and
+* the natural end race, and both outcomes are final.
+*
+* Order matters: ACP wants pending permission requests answered as cancelled,
+* so the parked agent requests are released before `session/cancel`. The
+* outbox-driven release that follows is a no-op on an empty park. The deadline
+* then bounds an agent that never settles (`ExpireCancel`).
+*/
+const cancelTurn = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	if (conversation.turn.state !== "running" || conversation.turn.turnId !== command.turnId) return;
+	const pending = conversation.snapshot().pending;
+	conversation.cancelTurn(command.turnId);
+	deps.conversations.save(conversation);
+	for (const permission of pending.permissions) deps.codingAgent.resolvePermission(permission.permissionId, { type: "cancelled" });
+	for (const elicitation of pending.elicitations) deps.codingAgent.resolveElicitation(elicitation.elicitationId, { type: "cancel" });
+	await deps.codingAgent.cancel(command.conversationId);
+	deps.scheduler.schedule(CANCEL_DEADLINE_MS, () => {
+		deps.background.run(deps.bus.handle(createCommand("ExpireCancel", {
+			conversationId: command.conversationId,
+			turnId: command.turnId
+		})));
+	});
+};
+//#endregion
+//#region src/application/handlers/close-conversation.ts
+/** Drop one conversation from this process. Unknown ids are a no-op. */
+const closeConversation = async (command, deps) => {
+	const conversation = deps.conversations.find(command.conversationId);
+	if (conversation === null) return;
+	if (conversation.turn.state === "running") await deps.codingAgent.cancel(conversation.id);
+	conversation.close();
+	deps.conversations.delete(conversation);
+	await deps.codingAgent.closeSession(conversation.id);
+};
+//#endregion
+//#region src/application/handlers/close-all-conversations.ts
+/** Shutdown: close every open conversation, then stop the agent process. */
+const closeAllConversations = async (_command, deps) => {
+	for (const conversation of deps.conversations.all()) await closeConversation(createCommand("CloseConversation", { conversationId: conversation.id }), deps);
+	await deps.codingAgent.stop();
+};
+//#endregion
+//#region src/application/handlers/close-idle-conversation.ts
+/**
+* Bound the Host's memory: close a conversation whose last turn ended a full
+* idle window ago. A running turn or fresh activity is a no-op; the timer that
+* follows the next `FinishTurn` will look again. A returning viewer re-attaches
+* and the session reloads.
+*/
+const closeIdleConversation = async (command, deps) => {
+	const conversation = deps.conversations.find(command.conversationId);
+	if (conversation === null) return;
+	if (conversation.turn.state === "running") return;
+	if (deps.now().getTime() - Date.parse(conversation.lastActivityAt) < 18e5) return;
+	await deps.bus.handle(createCommand("CloseConversation", { conversationId: command.conversationId }));
+};
+//#endregion
+//#region src/application/handlers/complete-elicitation.ts
+const completeElicitation = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	conversation.completeElicitation(command.elicitationId);
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/domain/conversation/conversation-view-reducer.ts
+/** A canonical event cannot update the current conversation view. */
+var ConversationViewError = class extends h("ConversationViewError") {
+	constructor(args) {
+		super({
+			...args,
+			classification: "terminal"
+		});
+	}
+};
+/** The view of a conversation before any event. */
+function emptyConversationView() {
+	return {
+		items: [],
+		tools: [],
+		plans: [],
+		pending: {
+			permissions: [],
+			elicitations: []
+		}
+	};
+}
+/**
+* Fold one canonical event into the view in place. Turn events are not the view's
+* concern; the aggregate tracks the turn. @throws ConversationViewError on a bad sequence.
+*/
+function applyConversationEvent(view, event) {
+	switch (event.type) {
+		case "message.started":
+			addItem(view, {
+				type: "message",
+				turnId: event.turnId,
+				messageId: event.messageId,
+				role: event.role,
+				content: []
+			});
+			return;
+		case "reasoning.started":
+			addItem(view, {
+				type: "reasoning",
+				turnId: event.turnId,
+				messageId: event.messageId,
+				content: []
+			});
+			return;
+		case "message.delta":
+			appendContent(view, event.messageId, "message", event.content);
+			return;
+		case "reasoning.delta":
+			appendContent(view, event.messageId, "reasoning", event.content);
+			return;
+		case "tool.updated": {
+			const index = view.tools.findIndex((tool) => tool.toolCallId === event.tool.toolCallId);
+			if (index === -1) {
+				view.tools.push(event.tool);
+				view.items.push({
+					type: "tool",
+					turnId: event.turnId,
+					toolCallId: event.tool.toolCallId
+				});
+			} else view.tools[index] = event.tool;
+			return;
+		}
+		case "plan.updated":
+			view.plans = [...view.plans.filter((plan) => plan.planId !== event.plan.planId), event.plan];
+			return;
+		case "plan.removed":
+			view.plans = view.plans.filter((plan) => plan.planId !== event.planId);
+			return;
+		case "conversation.usage.updated":
+			view.usage = event.usage;
+			return;
+		case "conversation.configuration.updated":
+			view.configuration = [...event.options];
+			return;
+		case "conversation.commands.updated":
+			view.commands = [...event.commands];
+			return;
+		case "conversation.mode.updated":
+			view.modeId = event.modeId;
+			return;
+		case "permission.requested":
+			view.pending.permissions.push({
+				turnId: event.turnId,
+				permissionId: event.permissionId,
+				toolCallId: event.toolCallId,
+				title: event.title,
+				options: [...event.options]
+			});
+			return;
+		case "permission.resolved":
+			view.pending.permissions = view.pending.permissions.filter((permission) => permission.permissionId !== event.permissionId);
+			return;
+		case "elicitation.requested":
+			view.pending.elicitations.push({
+				turnId: event.turnId,
+				elicitationId: event.elicitationId,
+				request: event.request
+			});
+			return;
+		case "elicitation.resolved":
+		case "elicitation.completed":
+			view.pending.elicitations = view.pending.elicitations.filter((elicitation) => elicitation.elicitationId !== event.elicitationId);
+			return;
+		case "turn.started":
+		case "turn.finished":
+		case "message.completed":
+		case "reasoning.completed":
+		case "conversation.metadata.updated":
+		case "conversation.failed": return;
+	}
+}
+function addItem(view, item) {
+	if (view.items.some((current) => current.type !== "tool" && current.messageId === item.messageId)) throw new ConversationViewError({ message: "The message already exists" });
+	view.items.push(item);
+}
+function appendContent(view, messageId, type, content) {
+	const item = view.items.find((current) => current.type !== "tool" && current.messageId === messageId);
+	if (item === void 0 || item.type !== type) throw new ConversationViewError({ message: "The message does not exist" });
+	item.content.push(content);
+}
+//#endregion
+//#region src/domain/conversation/message-identity.ts
+/**
+* Deterministic ids for what the coding agent does not name (§1: no `messageId`
+* on any chunk). The same transcript maps to the same ids on every load, so the
+* relay can replace its copy without a diff. The turn id itself is `turnIdFor`
+* in `@porte/core`, shared with the relay.
+*/
+function userMessageId(turnId) {
+	return MessageIdSchema.parse(`${turnId}:user`);
+}
+/** `ordinal` counts stream boundaries inside the turn, starting at 1. */
+function assistantMessageId(turnId, ordinal) {
+	return MessageIdSchema.parse(`${turnId}:assistant:${String(ordinal)}`);
+}
+function reasoningMessageId(turnId, ordinal) {
+	return MessageIdSchema.parse(`${turnId}:reasoning:${String(ordinal)}`);
+}
+function permissionId(turnId, acpRequestId) {
+	return PermissionIdSchema.parse(`${turnId}:permission:${String(acpRequestId)}`);
+}
+function elicitationId(turnId, acpRequestId) {
+	return ElicitationIdSchema.parse(`${turnId}:elicitation:${String(acpRequestId)}`);
+}
+//#endregion
+//#region src/domain/entity.ts
+/**
+* Base for aggregates: identity, raised events, and the shape the repository stores.
+* `id` keeps the branded type from `TData` (`ConversationId`, Grok's session id);
+* the host mints no aggregate id itself.
+*/
+var Entity = class {
+	events = [];
+	addEvent(event) {
+		this.events.push(event);
+	}
+	collectEvents() {
+		return [...this.events];
+	}
+	clearEvents() {
+		this.events = [];
+	}
+};
+//#endregion
+//#region src/infrastructure/grok/git-root.ts
+/**
+* The repository a directory belongs to, or undefined outside one.
+*
+* Mirrors what Grok records as a session facet, for the one case Grok has not
+* recorded yet: a conversation this host is creating right now.
+*
+* Nearest match wins, so a submodule reports itself rather than its parent. A
+* `.git` file counts as well as a directory, which is how a worktree resolves
+* to the worktree rather than to the checkout it was cut from.
+*/
+function findGitRoot(cwd) {
+	let directory = resolve(cwd);
+	for (;;) {
+		if (existsSync(`${directory}${sep}.git`)) return directory;
+		const parent = dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+/**
+* One spelling for one repository.
+*
+* Grok writes its facet with a trailing separator and this host resolves paths
+* without one. Both are the same repository, and the browser groups on the
+* string, so they have to arrive spelled the same way.
+*/
+function normaliseGitRoot(gitRoot) {
+	const trimmed = gitRoot.endsWith(sep) ? gitRoot.slice(0, -sep.length) : gitRoot;
+	return trimmed.length > 0 ? trimmed : sep;
+}
+//#endregion
+//#region src/domain/conversation/conversation.ts
+/**
+* One coding conversation open on this process.
+*
+* Owns the live turn and the transcript. Every transition raises the canonical
+* `ConversationEvent` the relay consumes, folds it into `state`, and wraps it as
+* `ConversationEventRaised`. The coding agent stays the system of record; `replay`
+* rebuilds `state` from its history without raising.
+*/
+var Conversation = class Conversation extends Entity {
+	data;
+	constructor(data) {
+		super();
+		this.data = data;
+	}
+	/** Start an empty conversation in a git workspace. */
+	static create(input) {
+		return new Conversation({
+			id: input.id,
+			cwd: input.cwd,
+			gitRoot: normaliseGitRoot(input.gitRoot),
+			title: "",
+			updatedAt: input.now.toISOString(),
+			state: {
+				turn: { state: "idle" },
+				...emptyConversationView()
+			},
+			lastActivityAt: input.now.toISOString()
+		});
+	}
+	/** Rebuild one conversation from coding-agent facts. Raises nothing. */
+	static restore(input) {
+		return new Conversation({
+			id: input.id,
+			cwd: input.cwd,
+			gitRoot: normaliseGitRoot(input.gitRoot),
+			title: input.title,
+			updatedAt: input.updatedAt,
+			state: {
+				turn: { state: "idle" },
+				...emptyConversationView()
+			},
+			lastActivityAt: input.updatedAt
+		});
+	}
+	get id() {
+		return this.data.id;
+	}
+	get cwd() {
+		return this.data.cwd;
+	}
+	get gitRoot() {
+		return this.data.gitRoot;
+	}
+	get title() {
+		return this.data.title;
+	}
+	get updatedAt() {
+		return this.data.updatedAt;
+	}
+	get turn() {
+		return this.data.state.turn;
+	}
+	/** A copy; later transitions do not change it. */
+	snapshot() {
+		return structuredClone(this.data.state);
+	}
+	toPlainObject() {
+		return this.data;
+	}
+	/** Fold the agent's history into the transcript without raising. Idle only. */
+	replay(events) {
+		if (this.data.state.turn.state !== "idle") throw new ConversationBusyError();
+		for (const event of events) this.fold(event);
+	}
+	/**
+	* Start a turn with the user's message and return the turn id this aggregate minted.
+	*
+	* The id is `turnIdFor(id, promptIndex)`, with `promptIndex` predicted as the
+	* count of user messages so far; the mapper checks it against Grok's own. A
+	* repeated `attemptId`, running or the last finished one, returns the same
+	* turn and starts nothing. Another turn running is `ConversationBusyError`.
+	*/
+	beginTurn(attemptId, userMessage) {
+		const last = this.data.lastAttempt;
+		if (last?.attemptId === attemptId) return last.turnId;
+		if (this.data.state.turn.state === "running") throw new ConversationBusyError();
+		const promptIndex = this.data.state.items.filter((item) => item.type === "message" && item.role === "user").length;
+		const turnId = turnIdFor(this.data.id, promptIndex);
+		const messageId = userMessageId(turnId);
+		this.data = {
+			...this.data,
+			state: {
+				...this.data.state,
+				turn: {
+					state: "running",
+					turnId,
+					attemptId
+				}
+			},
+			lastAttempt: {
+				attemptId,
+				turnId,
+				promptIndex
+			}
+		};
+		this.raise({
+			type: "turn.started",
+			turnId,
+			attemptId
+		});
+		this.raise({
+			type: "message.started",
+			turnId,
+			messageId,
+			role: "user"
+		});
+		for (const content of userMessage.content) this.raise({
+			type: "message.delta",
+			turnId,
+			messageId,
+			content
+		});
+		this.raise({
+			type: "message.completed",
+			turnId,
+			messageId
+		});
+		return turnId;
+	}
+	/** The prompt index behind the running or last turn, for the mapper's check. */
+	promptIndexOf(turnId) {
+		const last = this.data.lastAttempt;
+		if (last === void 0 || last.turnId !== turnId) throw new TurnNotFoundError();
+		return last.promptIndex;
+	}
+	/** The aggregate's current view of one tool call, for partial ACP updates. */
+	findTool(toolCallId) {
+		return this.data.state.tools.find((tool) => tool.toolCallId === toolCallId);
+	}
+	/** Record activity for idle eviction. */
+	touch(now) {
+		this.data = {
+			...this.data,
+			lastActivityAt: now
+		};
+	}
+	get lastActivityAt() {
+		return this.data.lastActivityAt;
+	}
+	/** Park a permission request on the running turn. */
+	requestPermission(request) {
+		const turnId = this.runningTurnId();
+		this.raise({
+			type: "permission.requested",
+			turnId,
+			...request
+		});
+	}
+	answerPermission(turnId, permissionId, optionId) {
+		const pending = this.data.state.pending.permissions.find((permission) => permission.turnId === turnId && permission.permissionId === permissionId);
+		if (pending === void 0 || !pending.options.some((option) => option.optionId === optionId)) throw new PermissionNotFoundError();
+		this.raise({
+			type: "permission.resolved",
+			turnId,
+			permissionId,
+			outcome: {
+				type: "selected",
+				optionId
+			}
+		});
+	}
+	/** Park an elicitation on the running turn. */
+	requestElicitation(request) {
+		const turnId = this.runningTurnId();
+		this.raise({
+			type: "elicitation.requested",
+			turnId,
+			...request
+		});
+	}
+	answerElicitation(turnId, elicitationId, answer) {
+		if (this.data.state.pending.elicitations.find((elicitation) => elicitation.turnId === turnId && elicitation.elicitationId === elicitationId) === void 0) throw new ElicitationNotFoundError();
+		this.raise({
+			type: "elicitation.resolved",
+			turnId,
+			elicitationId,
+			outcome: elicitationOutcome(answer)
+		});
+	}
+	/** The agent reports a URL elicitation finished after the user accepted it. */
+	completeElicitation(elicitationId) {
+		const turnId = this.runningTurnId();
+		this.raise({
+			type: "elicitation.completed",
+			turnId,
+			elicitationId
+		});
+	}
+	/**
+	* Resolve every pending interaction as cancelled. The turn stays running until
+	* the agent answers the prompt with `cancelled`. A turn that is not running is
+	* a no-op: cancel and the natural end may race, and both outcomes are final.
+	*/
+	cancelTurn(turnId) {
+		const turn = this.data.state.turn;
+		if (turn.state !== "running" || turn.turnId !== turnId) return;
+		this.cancelPending(turnId);
+	}
+	/** One turn's slice of the transcript, for `turn.get`. */
+	turnTranscript(turnId) {
+		const items = this.data.state.items.filter((item) => item.turnId === turnId);
+		if (items.length === 0) throw new TurnNotFoundError();
+		const toolCallIds = new Set(items.flatMap((item) => item.type === "tool" ? [item.toolCallId] : []));
+		const tools = this.data.state.tools.filter((tool) => toolCallIds.has(tool.toolCallId));
+		const last = this.data.lastAttempt;
+		const slice = last?.turnId === turnId ? {
+			turnId,
+			attemptId: last.attemptId,
+			items,
+			tools
+		} : {
+			turnId,
+			items,
+			tools
+		};
+		return structuredClone(slice);
+	}
+	/** End the turn. A turn that already ended is a no-op. */
+	finishTurn(turnId, outcome) {
+		const turn = this.data.state.turn;
+		if (turn.state !== "running" || turn.turnId !== turnId) return;
+		this.cancelPending(turnId);
+		this.data.state.turn = { state: "idle" };
+		this.raise({
+			type: "turn.finished",
+			turnId,
+			outcome
+		});
+	}
+	/** Leave this process: pending interactions resolve as cancelled, the socket can go. */
+	close() {
+		const turn = this.data.state.turn;
+		if (turn.state === "running") this.cancelPending(turn.turnId);
+		this.addEvent(createEvent("ConversationClosed", { conversationId: this.data.id }));
+	}
+	applyMetadata(update) {
+		this.data = {
+			...this.data,
+			title: update.title === void 0 ? this.data.title : update.title ?? "",
+			updatedAt: update.updatedAt ?? this.data.updatedAt
+		};
+		this.raise({
+			type: "conversation.metadata.updated",
+			update
+		});
+	}
+	/**
+	* Record events the coding agent produced during the live turn. Turn-scoped
+	* events need the running turn; metadata folds into the aggregate too.
+	*/
+	applyAgentEvents(events) {
+		for (const event of events) {
+			if (event.type === "conversation.metadata.updated") {
+				this.applyMetadata(event.update);
+				continue;
+			}
+			if ("turnId" in event) this.requireTurn(event.turnId);
+			this.raise(event);
+		}
+	}
+	raise(event) {
+		this.fold(event);
+		this.addEvent(createEvent("ConversationEventRaised", {
+			conversationId: this.data.id,
+			event
+		}));
+	}
+	fold(event) {
+		applyConversationEvent(this.data.state, event);
+	}
+	runningTurnId() {
+		const turn = this.data.state.turn;
+		if (turn.state !== "running") throw new TurnNotFoundError();
+		return turn.turnId;
+	}
+	requireTurn(turnId) {
+		if (this.runningTurnId() !== turnId) throw new TurnNotFoundError();
+	}
+	cancelPending(turnId) {
+		const { permissions, elicitations } = this.data.state.pending;
+		for (const { permissionId } of permissions) this.raise({
+			type: "permission.resolved",
+			turnId,
+			permissionId,
+			outcome: { type: "cancelled" }
+		});
+		for (const { elicitationId } of elicitations) this.raise({
+			type: "elicitation.resolved",
+			turnId,
+			elicitationId,
+			outcome: { type: "cancelled" }
+		});
+	}
+};
+function elicitationOutcome(answer) {
+	switch (answer.type) {
+		case "submit": return {
+			type: "submitted",
+			values: answer.values
+		};
+		case "accept": return { type: "accepted" };
+		case "decline": return { type: "declined" };
+		case "cancel": return { type: "cancelled" };
+	}
+}
+//#endregion
+//#region src/application/handlers/create-conversation.ts
+/** Create one coding-agent session in a git workspace and open it on this process. */
+const createConversation = async (command, deps) => {
+	const gitRoot = findGitRoot(command.cwd);
+	if (gitRoot === void 0) throw new WorkspaceNotAllowedError();
+	const session = await deps.codingAgent.createSession(command);
+	const conversation = Conversation.create({
+		id: session.id,
+		cwd: command.cwd,
+		gitRoot,
+		now: deps.now()
+	});
+	conversation.applyAgentEvents(session.events);
+	deps.conversations.insert(conversation);
+	return makeConversationSummary(conversation);
+};
+//#endregion
+//#region src/application/handlers/drop-conversation-socket.ts
+/** Effect: a closed conversation needs no relay socket. */
+const dropConversationSocket = async (event, deps) => {
+	deps.connections.closeConversation(event.conversationId);
+};
+//#endregion
+//#region src/application/handlers/expire-cancel.ts
+const logger$6 = createLogger("expire-cancel");
+/**
+* The cancel deadline fired. A prompt that settled meanwhile is a no-op; one
+* still running has an unresponsive agent: close its session so the mapper and
+* process state go with it, then finish the turn as cancelled. The next turn
+* reloads the session.
+*/
+const expireCancel = async (command, deps) => {
+	const conversation = deps.conversations.find(command.conversationId);
+	if (conversation === null) return;
+	const turn = conversation.turn;
+	if (turn.state !== "running" || turn.turnId !== command.turnId) return;
+	logger$6.warn("cancel_deadline_expired", {
+		error: new AgentUnresponsiveError(),
+		details: {
+			conversationId: command.conversationId,
+			turnId: command.turnId
+		}
+	});
+	await deps.codingAgent.closeSession(command.conversationId);
+	await deps.bus.handle(createCommand("FinishTurn", {
+		conversationId: command.conversationId,
+		turnId: command.turnId,
+		outcome: { type: "cancelled" }
+	}));
+};
+//#endregion
+//#region src/application/handlers/finish-turn.ts
+/** End a turn and start the idle clock. A conversation closed meanwhile has nothing to end. */
+const finishTurn = async (command, deps) => {
+	const conversation = deps.conversations.find(command.conversationId);
+	if (conversation === null) return;
+	if (command.usage !== void 0) conversation.applyAgentEvents([{
+		type: "conversation.usage.updated",
+		usage: command.usage
+	}]);
+	conversation.finishTurn(command.turnId, command.outcome);
+	conversation.touch(IsoDateTimeSchema.parse(deps.now().toISOString()));
+	deps.conversations.save(conversation);
+	const { conversationId } = command;
+	deps.scheduler.schedule(IDLE_EVICTION_MS, () => {
+		deps.background.run(deps.bus.handle(createCommand("CloseIdleConversation", { conversationId })));
+	});
+};
+//#endregion
+//#region src/application/handlers/get-conversation.ts
+/** The open conversation snapshot for the Worker first paint. */
+const getConversation = async (query, deps) => omitUnpersistableContent(deps.conversations.get(query.conversationId).snapshot());
+/** Drop tool bodies and media bytes the Worker SQLite row cannot store. */
+function omitUnpersistableContent(state) {
+	return {
+		...state,
+		items: state.items.map(omitUnpersistableItem),
+		tools: state.tools.map(omitUnpersistableTool)
+	};
+}
+/** Drop tool bodies and media bytes from one turn slice, as `conversation.get` does. */
+function omitUnpersistableTurn(turn) {
+	return {
+		turnId: turn.turnId,
+		items: turn.items.map(omitUnpersistableItem),
+		tools: turn.tools.map(omitUnpersistableTool)
+	};
+}
+function omitUnpersistableItem(item) {
+	if (item.type === "tool") return item;
+	return {
+		...item,
+		content: item.content.filter(isPersistableContent)
+	};
+}
+function isPersistableContent(content) {
+	return content.type === "text" || content.type === "resource-link";
+}
+function omitUnpersistableTool(tool) {
+	const next = {
+		toolCallId: tool.toolCallId,
+		title: tool.title,
+		kind: tool.kind,
+		status: tool.status,
+		content: [],
+		locations: tool.locations
+	};
+	if (tool.name !== void 0) next.name = tool.name;
+	if (tool._meta !== void 0) next._meta = tool._meta;
+	return next;
+}
+//#endregion
+//#region src/application/handlers/get-turn.ts
+/** One turn's items and tools, so the relay can write the finished turn under stable ids. */
+const getTurn = async (query, deps) => omitUnpersistableTurn(deps.conversations.get(query.conversationId).turnTranscript(query.turnId));
+//#endregion
+//#region src/application/handlers/list-conversations.ts
+/** One page of the agent's conversation list; rows without a git root are not conversations. */
+const listConversations = async (query, deps) => {
+	const page = await deps.codingAgent.listSessions(query.cursor);
+	const conversations = page.sessions.map(makeConversationSummary);
+	return page.next === void 0 ? { conversations } : {
+		conversations,
+		next: page.next
+	};
+};
+//#endregion
+//#region src/application/handlers/open-conversation.ts
+/**
+* Load an existing session onto this process and fold its history. Runs on
+* every conversation socket open; a conversation that is already open stays as is.
+*/
+const openConversation = async (command, deps) => {
+	if (deps.conversations.find(command.conversationId) !== null) return;
+	const gitRoot = findGitRoot(command.cwd);
+	if (gitRoot === void 0) throw new WorkspaceNotAllowedError();
+	const loaded = await deps.codingAgent.loadSession(command.conversationId, command.cwd);
+	const conversation = Conversation.restore({
+		id: command.conversationId,
+		cwd: command.cwd,
+		gitRoot,
+		title: loaded.title,
+		updatedAt: IsoDateTimeSchema.parse(deps.now().toISOString())
+	});
+	conversation.replay(loaded.events);
+	conversation.touch(IsoDateTimeSchema.parse(deps.now().toISOString()));
+	deps.conversations.insert(conversation);
+};
+//#endregion
+//#region src/application/handlers/publish-conversation-event.ts
+/** Effect: forward the canonical event to the relay; metadata also goes to the control socket. */
+const publishConversationEvent = async (raised, deps) => {
+	if (raised.event.type === "conversation.metadata.updated") deps.connections.control.conversationUpdated(raised.conversationId, raised.event.update);
+	deps.connections.conversation(raised.conversationId)?.sendEvent(raised.event);
+};
+//#endregion
+//#region src/application/handlers/release-parked-request.ts
+/** Effect: a resolved permission or elicitation answers the agent request parked for it. */
+const releaseParkedRequest = async (raised, deps) => {
+	const event = raised.event;
+	if (event.type === "permission.resolved") deps.codingAgent.resolvePermission(event.permissionId, event.outcome);
+	else if (event.type === "elicitation.resolved") deps.codingAgent.resolveElicitation(event.elicitationId, toAnswer(event.outcome));
+};
+function toAnswer(outcome) {
+	switch (outcome.type) {
+		case "submitted": return {
+			type: "submit",
+			values: outcome.values
+		};
+		case "accepted": return { type: "accept" };
+		case "declined": return { type: "decline" };
+		case "cancelled": return { type: "cancel" };
+	}
+}
+//#endregion
+//#region src/application/handlers/request-elicitation.ts
+const requestElicitation = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	conversation.requestElicitation({
+		elicitationId: command.elicitationId,
+		request: command.request
+	});
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/handlers/request-permission.ts
+const requestPermission = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	conversation.requestPermission({
+		permissionId: command.permissionId,
+		toolCallId: command.toolCallId,
+		title: command.title,
+		options: command.options
+	});
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/handlers/set-model.ts
+/** Switch the agent model; the relay learns the new value from `conversation.configuration.updated`. */
+const setModel = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	const events = await deps.codingAgent.setModel(command.conversationId, command.modelId);
+	conversation.applyAgentEvents(events);
+	deps.conversations.save(conversation);
+};
+//#endregion
+//#region src/application/handlers/start-turn.ts
+/**
+* Begin the turn now, run the prompt in the background, and end the turn with
+* `FinishTurn` when the agent answers. The relay sees `turn.started` before this returns.
+*
+* The aggregate mints the turn id and dedupes the attempt; a repeated attempt
+* begins nothing and sends no second prompt. A session the process no longer
+* holds (cancel deadline, idle eviction) is loaded again first.
+*/
+const startTurn = async (command, deps) => {
+	const conversation = deps.conversations.get(command.conversationId);
+	if (!deps.codingAgent.isOpen(conversation.id)) await deps.codingAgent.loadSession(conversation.id, conversation.cwd);
+	const wasRunning = conversation.turn.state === "running";
+	const turnId = conversation.beginTurn(command.attemptId, command.userMessage);
+	const turnAfter = conversation.turn;
+	if (wasRunning || turnAfter.state !== "running") {
+		deps.conversations.save(conversation);
+		return;
+	}
+	const promptIndex = conversation.promptIndexOf(turnId);
+	conversation.touch(IsoDateTimeSchema.parse(deps.now().toISOString()));
+	deps.conversations.save(conversation);
+	const { conversationId } = command;
+	deps.background.run(deps.codingAgent.prompt(conversationId, turnId, promptIndex, command.userMessage.content).then((result) => {
+		const finish = {
+			conversationId,
+			turnId,
+			outcome: result.outcome
+		};
+		if (result.usage !== void 0) finish.usage = result.usage;
+		return deps.bus.handle(createCommand("FinishTurn", finish));
+	}, (cause) => deps.bus.handle(createCommand("FinishTurn", {
+		conversationId,
+		turnId,
+		outcome: failedOutcome(cause)
+	}))));
+};
+/** The relay contract allows three tags; anything not transient is internal. */
+function failedOutcome(cause) {
+	const message = cause instanceof Error && cause.message.length > 0 ? cause.message : "Turn failed";
+	return {
+		type: "failed",
+		error: {
+			_tag: isClassifiedError(cause) && cause.classification === "transient" ? CODING_AGENT_UNAVAILABLE_ERROR : INTERNAL_SERVER_ERROR,
+			message
+		}
+	};
+}
+const DEFAULT_REGISTRY = {
+	commands: {
+		CreateConversation: createConversation,
+		OpenConversation: openConversation,
+		CloseConversation: closeConversation,
+		CloseAllConversations: closeAllConversations,
+		CloseIdleConversation: closeIdleConversation,
+		StartTurn: startTurn,
+		FinishTurn: finishTurn,
+		CancelTurn: cancelTurn,
+		ExpireCancel: expireCancel,
+		ApplyAgentUpdate: applyAgentUpdate,
+		RequestPermission: requestPermission,
+		AnswerPermission: answerPermission,
+		RequestElicitation: requestElicitation,
+		AnswerElicitation: answerElicitation,
+		CompleteElicitation: completeElicitation,
+		SetModel: setModel
+	},
+	events: {
+		ConversationEventRaised: [publishConversationEvent, releaseParkedRequest],
+		ConversationClosed: [dropConversationSocket]
+	},
+	queries: {
+		ListConversations: listConversations,
+		GetConversation: getConversation,
+		GetTurn: getTurn
+	}
+};
+//#endregion
+//#region src/application/message-bus.ts
+const logger$5 = createLogger("message-bus");
+/**
+* MessageBus - Central message processing system
+* - Commands: one handler; returns its result after the outbox drains.
+* - Events: raised by aggregates, pushed to the outbox by repositories, drained here after
+*   every handler and fanned out to every subscriber in parallel. A failed subscriber is
+*   logged once and never fails the command.
+* - Queries: one handler, read-only.
+*/
+var MessageBus = class {
+	deps;
+	commands;
+	events;
+	queries;
+	constructor(deps, registry = DEFAULT_REGISTRY) {
+		this.deps = deps;
+		this.commands = registry.commands;
+		this.events = registry.events;
+		this.queries = registry.queries;
+	}
+	async handle(message) {
+		try {
+			return await this.dispatch(message);
+		} finally {
+			await this.drainOutbox();
+		}
+	}
+	async dispatch(message) {
+		if (isCommand(message)) return this.handleCommand(message);
+		if (isQuery(message)) return this.handleQuery(message);
+		if (isEvent(message)) await this.handleEvent(message);
+	}
+	async handleCommand(command) {
+		const handler = this.commands[command.name];
+		if (handler === void 0) throw new NoHandlerError({
+			kind: "command",
+			name: command.name
+		});
+		return handler(command, this.deps);
+	}
+	async handleQuery(query) {
+		const handler = this.queries[query.name];
+		if (handler === void 0) throw new NoHandlerError({
+			kind: "query",
+			name: query.name
+		});
+		return handler(query, this.deps);
+	}
+	async handleEvent(event) {
+		const handlers = this.events[event.name] ?? [];
+		const outcomes = await Promise.allSettled(handlers.map((handler) => handler(event, this.deps)));
+		for (const [index, outcome] of outcomes.entries()) {
+			if (outcome.status === "fulfilled") continue;
+			logger$5.error("event_handler_failed", {
+				error: outcome.reason,
+				details: {
+					eventName: event.name,
+					handlerIndex: index
+				}
+			});
+		}
+	}
+	async drainOutbox() {
+		for (let events = this.deps.outbox.drain(); events.length > 0; events = this.deps.outbox.drain()) for (const event of events) await this.handleEvent(event);
+	}
+};
+//#endregion
+//#region src/entrypoints/acp/acp-inbound.ts
+/**
+* ACP → bus. What the agent pushes becomes commands; each runs as background
+* work so a failing one is logged once there and never blocks the agent.
+*/
+function createAgentInbound(bus, background) {
+	return {
+		onEvents: (conversationId, events) => {
+			background.run(bus.handle(createCommand("ApplyAgentUpdate", {
+				conversationId,
+				events
+			})));
+		},
+		onPermissionRequest: (conversationId, request) => {
+			background.run(bus.handle(createCommand("RequestPermission", {
+				conversationId,
+				...request
+			})));
+		},
+		onElicitationRequest: (conversationId, request) => {
+			background.run(bus.handle(createCommand("RequestElicitation", {
+				conversationId,
+				...request
+			})));
+		},
+		onElicitationComplete: (conversationId, elicitationId) => {
+			background.run(bus.handle(createCommand("CompleteElicitation", {
+				conversationId,
+				elicitationId
+			})));
+		}
+	};
+}
+//#endregion
+//#region src/entrypoints/websocket/control-method-handlers.ts
+/** Parse → one bus message → answer. No logic lives here. */
+const CONTROL_METHOD_HANDLERS = {
+	"conversations.list": (params, context) => context.bus.handle(createQuery("ListConversations", params)),
+	"conversation.create": (params, context) => context.bus.handle(createCommand("CreateConversation", params)),
+	"conversation.attach": async (params, context) => {
+		context.connections.connectConversation(params.conversationId, params.cwd);
+		return null;
+	}
+};
+//#endregion
+//#region src/application/ports/coding-agent.ts
+/** The one configuration option the host exposes; `conversation.configuration.set` targets it. */
+const MODEL_OPTION_ID = "model";
+//#endregion
+//#region src/entrypoints/websocket/conversation-method-handlers.ts
+/** Parse → one bus message → answer. No logic lives here. */
+const CONVERSATION_METHOD_HANDLERS = {
+	"conversation.close": async (_params, { bus, conversationId }) => {
+		await bus.handle(createCommand("CloseConversation", { conversationId }));
+		return null;
+	},
+	"conversation.get": (_params, { bus, conversationId }) => bus.handle(createQuery("GetConversation", { conversationId })),
+	"turn.start": async (params, { bus, conversationId }) => {
+		await bus.handle(createCommand("StartTurn", {
+			conversationId,
+			...params
+		}));
+		return null;
+	},
+	"turn.get": (params, { bus, conversationId }) => bus.handle(createQuery("GetTurn", {
+		conversationId,
+		turnId: params.turnId
+	})),
+	"turn.cancel": async (params, { bus, conversationId }) => {
+		await bus.handle(createCommand("CancelTurn", {
+			conversationId,
+			turnId: params.turnId
+		}));
+		return null;
+	},
+	"conversation.configuration.set": async (params, { bus, conversationId }) => {
+		if (params.optionId !== "model" || params.value.type !== "select") throw new ConfigurationNotFoundError();
+		await bus.handle(createCommand("SetModel", {
+			conversationId,
+			modelId: params.value.value
+		}));
+		return null;
+	},
+	"permission.answer": async (params, { bus, conversationId }) => {
+		await bus.handle(createCommand("AnswerPermission", {
+			conversationId,
+			...params
+		}));
+		return null;
+	},
+	"elicitation.answer": async (params, { bus, conversationId }) => {
+		await bus.handle(createCommand("AnswerElicitation", {
+			conversationId,
+			...params
+		}));
+		return null;
+	}
+};
+//#endregion
+//#region src/infrastructure/errors/to-error-payload.ts
+const logger$4 = createLogger("error-boundary");
+/** Convert one Host failure into the contract a JSON-RPC client may see. Logs once. */
+function toErrorPayload(cause) {
+	const mapped = mapHostFailure(cause);
+	if (mapped !== void 0) return serializeDomainError(mapped);
+	return serializeUnknownFailure(cause);
+}
+function mapHostFailure(cause) {
+	return isDomainError(cause) ? cause : void 0;
+}
+function serializeDomainError(failure) {
+	logger$4.warn("handled_domain_error", {
+		error: failure,
+		details: { tag: failure._tag }
+	});
+	return failure._tag === "ValidationError" ? {
+		_tag: failure._tag,
+		message: failure.message,
+		issues: [...failure.issues]
+	} : {
+		_tag: failure._tag,
+		message: failure.message
+	};
+}
+function serializeUnknownFailure(cause) {
+	const classification = isClassifiedError(cause) ? cause.classification : "unknown";
+	logger$4.error("unexpected_error", {
+		error: cause,
+		details: { classification }
+	});
+	const replacement = classification === "transient" ? new ServiceUnavailableError() : new InternalServerError();
+	return {
+		_tag: replacement._tag,
+		message: replacement.message
+	};
+}
+//#endregion
+//#region src/entrypoints/websocket/json-rpc-handler.ts
+/** Create one JSON-RPC onFrame that returns a response document or nothing. */
+function createJsonRpcHandler(input) {
+	return (frame) => handleFrame(frame, input);
+}
+async function handleFrame(frame, input) {
+	try {
+		const incoming = readJsonRpcIncoming(frame, input.methods, input.requestId);
+		if (incoming.kind === "notification") {
+			const handler = input.notificationHandlers[incoming.data.method];
+			if (handler === void 0) throw new JsonRpcReadError({
+				id: null,
+				code: JSON_RPC_ERROR_CODES.methodNotFound,
+				message: "Method not found"
+			});
+			await handler(incoming.data.params, input.context);
+			return;
+		}
+		if (incoming.kind === "response") throw new JsonRpcReadError({
+			id: null,
+			code: JSON_RPC_ERROR_CODES.invalidRequest,
+			message: "Invalid Request"
+		});
+		return await handleJsonRpcRequest(incoming.data, (params) => input.handlers[incoming.data.method](params, input.context), (cause) => ({
+			code: HOST_APPLICATION_ERROR_CODE,
+			message: HOST_APPLICATION_ERROR_MESSAGE,
+			data: toErrorPayload(cause)
+		}));
+	} catch (cause) {
+		if (cause instanceof JsonRpcReadError) return jsonRpcError(cause.id, cause.code, cause.message);
+		throw cause;
+	}
+}
+//#endregion
+//#region src/infrastructure/websocket/websocket-notifications.ts
+/** Numbers every notification on one connection, from 1; the relay applies them in this order. */
+function sequence() {
+	let last = 0;
+	return () => {
+		last += 1;
+		return SequenceNumberSchema.parse(last);
+	};
+}
+/** Send application notifications through the control connection. */
+function createControlNotifications(send) {
+	const next = sequence();
+	return { conversationUpdated: (conversationId, update) => {
+		send(JSON.stringify(jsonRpcNotification("conversation.updated", {
+			seq: next(),
+			conversationId,
+			update
+		})));
+	} };
+}
+/** Send application notifications through one conversation connection. */
+function createConversationNotifications(send) {
+	const next = sequence();
+	return { sendEvent: (event) => {
+		send(JSON.stringify(jsonRpcNotification("conversation.event", {
+			seq: next(),
+			event
+		})));
+	} };
+}
+//#endregion
+//#region src/entrypoints/websocket/control-connection.ts
+/** Owns the control JSON-RPC endpoint and its socket. */
+var ControlConnection = class {
+	transport;
+	notifications;
+	stopped;
+	onFrame;
+	constructor(transport, handlers, context) {
+		this.transport = transport;
+		this.notifications = createControlNotifications((frame) => transport.send(frame));
+		this.stopped = transport.stopped;
+		this.onFrame = createJsonRpcHandler({
+			methods: HostControlMethods,
+			requestId: HostRequestIdSchema,
+			handlers,
+			notificationHandlers: {},
+			context
+		});
+	}
+	start(onStatus) {
+		this.transport.start({
+			onFrame: this.onFrame,
+			onStatus
+		});
+	}
+	stop() {
+		this.transport.stop();
+	}
+};
+//#endregion
+//#region src/entrypoints/websocket/conversation-connection.ts
+/** Owns one conversation JSON-RPC endpoint and its socket. */
+var ConversationConnection = class {
+	conversationId;
+	transport;
+	notifications;
+	/** Settles once, when this conversation socket will not come back. */
+	stopped;
+	onFrame;
+	onUp;
+	constructor(conversationId, cwd, transport, handlers, bus) {
+		this.conversationId = conversationId;
+		this.transport = transport;
+		this.notifications = createConversationNotifications((frame) => transport.send(frame));
+		this.stopped = transport.stopped;
+		this.onFrame = createJsonRpcHandler({
+			methods: HostConversationMethods,
+			requestId: HostRequestIdSchema,
+			handlers,
+			notificationHandlers: {},
+			context: {
+				conversationId,
+				bus
+			}
+		});
+		this.onUp = () => bus.handle(createCommand("OpenConversation", {
+			conversationId,
+			cwd
+		}));
+	}
+	start() {
+		this.transport.start({
+			onFrame: this.onFrame,
+			onUp: this.onUp
+		});
+	}
+	stop() {
+		this.transport.stop();
+	}
+};
+//#endregion
+//#region src/entrypoints/websocket/host-connection-manager.ts
+const logger$3 = createLogger("host-connection-manager");
+/** Owns the control connection and the active conversation connection registry. */
+var HostConnectionManager = class {
+	input;
+	createTransport;
+	controlConnection;
+	conversations = /* @__PURE__ */ new Map();
+	constructor(input, createTransport) {
+		this.input = input;
+		this.createTransport = createTransport;
+		const transport = createTransport({
+			url: this.controlUrl(),
+			subprotocol: HOST_CONTROL_SUBPROTOCOL,
+			authorization: `Bearer ${input.token}`
+		});
+		this.controlConnection = new ControlConnection(transport, input.controlHandlers, {
+			bus: input.bus,
+			connections: this
+		});
+	}
+	get controlStopped() {
+		return this.controlConnection.stopped;
+	}
+	get control() {
+		return this.controlConnection.notifications;
+	}
+	connectControl(onStatus) {
+		this.controlConnection.start(onStatus);
+	}
+	connectConversation(conversationId, cwd) {
+		if (this.conversations.has(conversationId)) return;
+		const connection = new ConversationConnection(conversationId, cwd, this.createTransport({
+			url: this.conversationUrl(conversationId),
+			subprotocol: HOST_CONVERSATION_SUBPROTOCOL,
+			authorization: `Bearer ${this.input.token}`
+		}), this.input.conversationHandlers, this.input.bus);
+		this.conversations.set(conversationId, connection);
+		connection.stopped.then(() => {
+			this.removeConversation(connection);
+		}, (cause) => {
+			logger$3.error("host_conversation_connection_failed", {
+				error: cause,
+				details: { conversationId }
+			});
+			this.removeConversation(connection);
+		});
+		connection.start();
+	}
+	conversation(conversationId) {
+		return this.conversations.get(conversationId)?.notifications ?? null;
+	}
+	closeConversation(conversationId) {
+		const connection = this.conversations.get(conversationId);
+		if (connection === void 0) return;
+		connection.stop();
+		this.removeConversation(connection);
+	}
+	closeAll() {
+		for (const connection of this.conversations.values()) connection.stop();
+		this.conversations.clear();
+		this.controlConnection.stop();
+	}
+	removeConversation(connection) {
+		if (this.conversations.get(connection.conversationId) === connection) this.conversations.delete(connection.conversationId);
+	}
+	controlUrl() {
+		const url = new URL("/api/host/ws", this.input.baseUrl);
+		url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+		return url.href;
+	}
+	conversationUrl(conversationId) {
+		const url = new URL(this.controlUrl());
+		url.pathname = `${url.pathname.replace(/\/$/, "")}/sub/conversation-agent/${encodeURIComponent(conversationId)}`;
+		return url.href;
+	}
+};
+//#endregion
+//#region src/infrastructure/acp/acp-content.ts
+/**
+* ACP `models` on a session response (spec 1, `session/new|load|resume`). The SDK
+* types predate it, so it is parsed off the raw response here.
+*/
+const sessionModelsSchema = object({
+	currentModelId: string().min(1),
+	availableModels: array(object({
+		modelId: string().min(1),
+		name: string().min(1),
+		description: string().nullish(),
+		_meta: record(string(), unknown()).nullish()
+	}))
+});
+/** `models` from a session response, or undefined when the agent sent none. */
+function parseSessionModels(response) {
+	const parsed = object({ models: sessionModelsSchema.optional() }).safeParse(response);
+	return parsed.success ? parsed.data.models : void 0;
+}
+/** Present the agent's model list as the one `select` option the relay contract knows. */
+function modelsToConfiguration(models, currentModelId = models.currentModelId) {
+	return {
+		type: "select",
+		id: MODEL_OPTION_ID,
+		name: "Model",
+		category: "model",
+		currentValue: currentModelId,
+		options: models.availableModels.map((model) => {
+			const option = {
+				type: "option",
+				value: model.modelId,
+				name: model.name
+			};
+			if (model.description !== void 0 && model.description !== null) option.description = model.description;
+			return option;
+		})
+	};
+}
+/** Canonical prompt content → ACP content block. Inverse of `mapCanonicalContent` for prompts. */
+function toAcpContent(content) {
+	if (content.type === "resource-link") {
+		const link = {
+			type: "resource_link",
+			uri: content.uri,
+			name: content.name
+		};
+		if (content.title !== void 0) link.title = content.title;
+		if (content.description !== void 0) link.description = content.description;
+		if (content.mimeType !== void 0) link.mimeType = content.mimeType;
+		if (content.size !== void 0) link.size = content.size;
+		return link;
+	}
+	if (content.type !== "resource") return content;
+	const resource = content.resource;
+	const embedded = resource.content.type === "text" ? {
+		uri: resource.uri,
+		text: resource.content.text
+	} : {
+		uri: resource.uri,
+		blob: resource.content.data
+	};
+	if (resource.mimeType !== void 0) embedded.mimeType = resource.mimeType;
+	return {
+		type: "resource",
+		resource: embedded
+	};
+}
+function mapCommand(command) {
+	const mapped = {
+		name: command.name,
+		description: command.description
+	};
+	if (command.input !== void 0 && command.input !== null) mapped.inputHint = command.input.hint;
+	return mapped;
+}
+function mapConfiguration(option) {
+	if (option.type === "boolean") {
+		const mapped = {
+			type: "boolean",
+			id: option.id,
+			name: option.name,
+			currentValue: option.currentValue
+		};
+		if (option.description !== void 0 && option.description !== null) mapped.description = option.description;
+		if (option.category !== void 0 && option.category !== null) mapped.category = option.category;
+		return mapped;
+	}
+	const mapped = {
+		type: "select",
+		id: option.id,
+		name: option.name,
+		currentValue: option.currentValue,
+		options: option.options.map((value) => {
+			if ("group" in value) return {
+				type: "group",
+				group: value.group,
+				name: value.name,
+				options: value.options.map(mapSelectConfigurationValue)
+			};
+			return mapSelectConfigurationValue(value);
+		})
+	};
+	if (option.description !== void 0 && option.description !== null) mapped.description = option.description;
+	if (option.category !== void 0 && option.category !== null) mapped.category = option.category;
+	return mapped;
+}
+function mapSelectConfigurationValue(value) {
+	const item = {
+		type: "option",
+		value: value.value,
+		name: value.name
+	};
+	if (value.description !== void 0 && value.description !== null) item.description = value.description;
+	return item;
+}
+function mapPlan(plan) {
+	if (plan.type === "items") return {
+		type: "items",
+		planId: plan.planId,
+		entries: plan.entries
+	};
+	if (plan.type === "file") return {
+		type: "file",
+		planId: plan.planId,
+		uri: plan.uri
+	};
+	return {
+		type: "markdown",
+		planId: plan.planId,
+		content: plan.content
+	};
+}
+function mapCanonicalContent(content) {
+	if (content.type === "resource_link") {
+		const mapped = {
+			type: "resource-link",
+			uri: content.uri,
+			name: content.name
+		};
+		if (content.title !== void 0 && content.title !== null) mapped.title = content.title;
+		if (content.description !== void 0 && content.description !== null) mapped.description = content.description;
+		if (content.mimeType !== void 0 && content.mimeType !== null) mapped.mimeType = content.mimeType;
+		if (content.size !== void 0 && content.size !== null) mapped.size = content.size;
+		copyContentMetadata(mapped, content);
+		return mapped;
+	}
+	if (content.type === "resource") {
+		const resource = {
+			uri: content.resource.uri,
+			content: "text" in content.resource ? {
+				type: "text",
+				text: content.resource.text
+			} : {
+				type: "blob",
+				data: content.resource.blob
+			}
+		};
+		if (content.resource.mimeType !== void 0 && content.resource.mimeType !== null) resource.mimeType = content.resource.mimeType;
+		if (content.resource._meta !== void 0 && content.resource._meta !== null) resource._meta = mapMeta(content.resource._meta);
+		const mapped = {
+			type: "resource",
+			resource
+		};
+		copyContentMetadata(mapped, content);
+		return mapped;
+	}
+	let mapped;
+	if (content.type === "text") mapped = {
+		type: "text",
+		text: content.text
+	};
+	else if (content.type === "audio") mapped = {
+		type: "audio",
+		data: content.data,
+		mimeType: content.mimeType
+	};
+	else {
+		mapped = {
+			type: "image",
+			data: content.data,
+			mimeType: content.mimeType
+		};
+		if (content.uri !== void 0 && content.uri !== null) mapped.uri = content.uri;
+	}
+	copyContentMetadata(mapped, content);
+	return mapped;
+}
+function mapToolContent(content) {
+	if (content.type === "content") {
+		const mapped = {
+			type: "content",
+			content: mapCanonicalContent(content.content)
+		};
+		if (content._meta !== void 0 && content._meta !== null) mapped._meta = mapMeta(content._meta);
+		return mapped;
+	}
+	if (content.type === "diff") {
+		const mapped = {
+			type: "diff",
+			path: content.path,
+			oldText: content.oldText ?? null,
+			newText: content.newText
+		};
+		if (content._meta !== void 0 && content._meta !== null) mapped._meta = mapMeta(content._meta);
+		return mapped;
+	}
+	const mapped = {
+		type: "terminal",
+		terminalId: content.terminalId
+	};
+	if (content._meta !== void 0 && content._meta !== null) mapped._meta = mapMeta(content._meta);
+	return mapped;
+}
+function copyContentMetadata(target, source) {
+	if (source.annotations !== void 0 && source.annotations !== null) {
+		const annotations = {};
+		if (source.annotations.audience !== void 0 && source.annotations.audience !== null) annotations.audience = [...source.annotations.audience];
+		if (source.annotations.lastModified !== void 0 && source.annotations.lastModified !== null) annotations.lastModified = source.annotations.lastModified;
+		if (source.annotations.priority !== void 0 && source.annotations.priority !== null) annotations.priority = source.annotations.priority;
+		if (source.annotations._meta !== void 0 && source.annotations._meta !== null) annotations._meta = mapMeta(source.annotations._meta);
+		target.annotations = annotations;
+	}
+	if (source._meta !== void 0 && source._meta !== null) target._meta = mapMeta(source._meta);
+}
+function mapJson(value) {
+	const parsed = json().safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function mapMeta(value) {
+	if (value === null || value === void 0) return void 0;
+	const parsed = record(string(), json()).safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function mapLocation(location) {
+	const mapped = { path: location.path };
+	if (location.line !== void 0 && location.line !== null) mapped.line = location.line;
+	return mapped;
+}
+//#endregion
+//#region src/infrastructure/acp/acp-update-mapper.ts
+const logger$2 = createLogger("acp-update-mapper");
+/** Grok's per-turn key on `user_message_chunk._meta`; the only stable turn id in a replay. */
+const promptIndexSchema = number().int().nonnegative();
+/** The agent sent an update in an order the mapper cannot place. */
+var AcpUpdateSequenceError = class extends h("AcpUpdateSequenceError") {
+	constructor(message) {
+		super({
+			message,
+			classification: "terminal"
+		});
+	}
+};
+/** The agent sent a value that cannot form a canonical event. */
+var AcpUpdateValueError = class extends h("AcpUpdateValueError") {
+	constructor(message) {
+		super({
+			message,
+			classification: "terminal"
+		});
+	}
+};
+/** The agent sent an update for a different session. */
+var AcpSessionMismatchError = class extends h("AcpSessionMismatchError") {
+	constructor() {
+		super({
+			message: "ACP update belongs to a different session",
+			classification: "terminal"
+		});
+	}
+};
+/**
+* Converts ACP `session/update` notifications into canonical events, for replay
+* (`session/load`) and live turns alike. One instance per open conversation.
+*
+* Grok names no message (§1 of the redesign doc), so ids come from stream
+* boundaries: a chunk on a stream with no open message starts one; `tool_call`
+* and the end of a turn close every open stream. Turn events themselves belong
+* to the `Conversation` aggregate; the mapper never emits `turn.*`.
+*/
+var AcpUpdateMapper = class {
+	conversationId;
+	turn;
+	ordinal = 0;
+	open = /* @__PURE__ */ new Map();
+	tools = /* @__PURE__ */ new Map();
+	commandsKey;
+	expectedPromptIndex;
+	promptIndexChecked = false;
+	/**
+	* @param conversationId - The session every update must belong to.
+	*
+	* The mapper keeps its own tool views: the aggregate applies events through
+	* the bus asynchronously, so a `tool_call_update` can arrive before the
+	* aggregate has folded the `tool_call` it patches.
+	*/
+	constructor(conversationId) {
+		this.conversationId = conversationId;
+	}
+	/** The relay turn in flight, if any. Replay turns are not live. */
+	get liveTurnId() {
+		return this.turn?.live === true ? this.turn.turnId : void 0;
+	}
+	/**
+	* A relay turn starts; its user message is raised by the aggregate, not mapped.
+	*
+	* `expectedPromptIndex` is the aggregate's prediction behind `turnId`. The first
+	* live `user_message_chunk` carries Grok's `_meta.promptIndex`; a mismatch is an
+	* invariant error, logged once by the caller.
+	*/
+	beginTurn(turnId, expectedPromptIndex) {
+		if (this.turn?.live === true) throw new AcpUpdateSequenceError("A live turn is already active");
+		this.turn = {
+			turnId,
+			live: true
+		};
+		this.expectedPromptIndex = expectedPromptIndex;
+		this.promptIndexChecked = false;
+		this.ordinal = 0;
+		this.open.clear();
+	}
+	/** The prompt settled: close every open stream. */
+	endTurn() {
+		if (this.turn?.live !== true) throw new AcpUpdateSequenceError("No live turn is active");
+		const events = this.events(this.closeStreams());
+		this.turn = void 0;
+		return events;
+	}
+	map(notification) {
+		if (notification.sessionId !== this.conversationId) throw new AcpSessionMismatchError();
+		return this.events(this.mapUpdate(notification.update));
+	}
+	mapUpdate(update) {
+		switch (update.sessionUpdate) {
+			case "user_message_chunk":
+				if (this.turn?.live === true) {
+					this.checkPromptIndex(update);
+					return [];
+				}
+				return [...this.startReplayTurn(update), ...this.mapContent("user", update)];
+			case "agent_message_chunk": return this.mapContent("assistant", update);
+			case "agent_thought_chunk": return this.mapContent("reasoning", update);
+			case "tool_call": return this.mapToolCall(update);
+			case "tool_call_update": return this.mapToolCallUpdate(update);
+			case "plan": return [{
+				type: "plan.updated",
+				turnId: this.requireTurn(),
+				plan: {
+					type: "items",
+					planId: "legacy",
+					entries: update.entries
+				}
+			}];
+			case "plan_update": return [{
+				type: "plan.updated",
+				turnId: this.requireTurn(),
+				plan: mapPlan(update.plan)
+			}];
+			case "plan_removed": return [{
+				type: "plan.removed",
+				turnId: this.requireTurn(),
+				planId: update.planId
+			}];
+			case "available_commands_update": return this.mapCommands(update.availableCommands.map(mapCommand));
+			case "current_mode_update": return [{
+				type: "conversation.mode.updated",
+				modeId: update.currentModeId
+			}];
+			case "config_option_update": return [{
+				type: "conversation.configuration.updated",
+				options: update.configOptions.map(mapConfiguration)
+			}];
+			case "session_info_update": return mapSessionInfo(update);
+			case "usage_update": {
+				const usage = {
+					usedTokens: update.used,
+					sizeTokens: update.size
+				};
+				if (update.cost !== void 0 && update.cost !== null) usage.cost = update.cost;
+				return [{
+					type: "conversation.usage.updated",
+					usage
+				}];
+			}
+			case "compaction_update":
+			case "compaction_summary_chunk": throw new AcpUpdateValueError("ACP sent a compaction update that Porte did not advertise");
+		}
+		return update;
+	}
+	/**
+	* The aggregate predicted the prompt index behind the live turn id; Grok's
+	* `_meta.promptIndex` on the echo is the truth. A mismatch means the ids of
+	* this turn flip on the next replay, so it is logged loudly, once.
+	*/
+	checkPromptIndex(update) {
+		if (this.promptIndexChecked) return;
+		this.promptIndexChecked = true;
+		const actual = promptIndexSchema.safeParse(update._meta?.promptIndex);
+		if (!actual.success || actual.data === this.expectedPromptIndex) return;
+		logger$2.warn("prompt_index_mismatch", { details: {
+			conversationId: this.conversationId,
+			expected: this.expectedPromptIndex,
+			actual: actual.data
+		} });
+	}
+	/** Grok fires the same ~100 KB command list after every tool call; emit it once. */
+	mapCommands(commands) {
+		const key = JSON.stringify(commands);
+		if (key === this.commandsKey) return [];
+		this.commandsKey = key;
+		return [{
+			type: "conversation.commands.updated",
+			commands: [...commands]
+		}];
+	}
+	startReplayTurn(update) {
+		const promptIndex = promptIndexSchema.safeParse(update._meta?.promptIndex);
+		if (!promptIndex.success) throw new AcpUpdateValueError("ACP replay user message has no promptIndex");
+		const turnId = turnIdFor(this.conversationId, promptIndex.data);
+		if (this.turn?.live === false && this.turn.turnId === turnId) return [];
+		const closed = this.closeStreams();
+		this.turn = {
+			turnId,
+			live: false
+		};
+		this.ordinal = 0;
+		return closed;
+	}
+	mapContent(stream, update) {
+		const turnId = this.requireTurn();
+		const events = [];
+		let messageId = this.open.get(stream);
+		if (messageId === void 0) {
+			messageId = this.messageId(stream, turnId, update.messageId);
+			this.open.set(stream, messageId);
+			events.push(stream === "reasoning" ? {
+				type: "reasoning.started",
+				turnId,
+				messageId
+			} : {
+				type: "message.started",
+				turnId,
+				messageId,
+				role: stream
+			});
+		}
+		const content = mapCanonicalContent(update.content);
+		events.push(stream === "reasoning" ? {
+			type: "reasoning.delta",
+			turnId,
+			messageId,
+			content
+		} : {
+			type: "message.delta",
+			turnId,
+			messageId,
+			content
+		});
+		return events;
+	}
+	messageId(stream, turnId, acpMessageId) {
+		if (acpMessageId !== void 0 && acpMessageId !== null) {
+			const parsed = MessageIdSchema.safeParse(acpMessageId);
+			if (!parsed.success) throw new AcpUpdateValueError("ACP message ID is invalid");
+			return parsed.data;
+		}
+		if (stream === "user") return userMessageId(turnId);
+		this.ordinal += 1;
+		return stream === "assistant" ? assistantMessageId(turnId, this.ordinal) : reasoningMessageId(turnId, this.ordinal);
+	}
+	mapToolCall(update) {
+		const turnId = this.requireTurn();
+		const parsed = ToolViewSchema.safeParse({
+			toolCallId: update.toolCallId,
+			title: update.title,
+			kind: update.kind ?? "other",
+			status: update.status ?? "pending",
+			name: update.name ?? void 0,
+			content: (update.content ?? []).map(mapToolContent),
+			locations: (update.locations ?? []).map(mapLocation),
+			rawInput: mapJson(update.rawInput),
+			rawOutput: mapJson(update.rawOutput),
+			_meta: mapMeta(update._meta)
+		});
+		if (!parsed.success) throw new AcpUpdateValueError("ACP tool call is invalid");
+		this.tools.set(update.toolCallId, parsed.data);
+		const events = this.closeStreams();
+		events.push({
+			type: "tool.updated",
+			turnId,
+			tool: parsed.data
+		});
+		return events;
+	}
+	mapToolCallUpdate(update) {
+		const turnId = this.requireTurn();
+		const current = this.tools.get(update.toolCallId);
+		if (current === void 0) throw new AcpUpdateSequenceError("ACP updated a tool call before it started");
+		const next = { ...current };
+		if (update.title !== void 0 && update.title !== null) next.title = update.title;
+		if (update.name !== void 0 && update.name !== null) next.name = update.name;
+		if (update.kind !== void 0 && update.kind !== null) next.kind = update.kind;
+		if (update.status !== void 0 && update.status !== null) next.status = update.status;
+		if (update.content !== void 0 && update.content !== null) next.content = update.content.map(mapToolContent);
+		if (update.locations !== void 0 && update.locations !== null) next.locations = update.locations.map(mapLocation);
+		if (update.rawInput !== void 0) next.rawInput = mapJson(update.rawInput);
+		if (update.rawOutput !== void 0) next.rawOutput = mapJson(update.rawOutput);
+		if (update._meta !== void 0 && update._meta !== null) next._meta = mapMeta(update._meta);
+		const parsed = ToolViewSchema.safeParse(next);
+		if (!parsed.success) throw new AcpUpdateValueError("ACP tool update is invalid");
+		this.tools.set(update.toolCallId, parsed.data);
+		return [{
+			type: "tool.updated",
+			turnId,
+			tool: parsed.data
+		}];
+	}
+	closeStreams() {
+		const turn = this.turn;
+		if (turn === void 0) return [];
+		const closed = [];
+		for (const [stream, messageId] of this.open) closed.push(stream === "reasoning" ? {
+			type: "reasoning.completed",
+			turnId: turn.turnId,
+			messageId
+		} : {
+			type: "message.completed",
+			turnId: turn.turnId,
+			messageId
+		});
+		this.open.clear();
+		return closed;
+	}
+	requireTurn() {
+		if (this.turn === void 0) throw new AcpUpdateSequenceError("ACP update arrived outside a turn");
+		return this.turn.turnId;
+	}
+	events(data) {
+		return data.map((item) => {
+			const parsed = ConversationEventSchema.safeParse(item);
+			if (!parsed.success) throw new AcpUpdateValueError("ACP update cannot form a canonical event");
+			return parsed.data;
+		});
+	}
+};
+function mapSessionInfo(update) {
+	if (update.title === void 0 && update.updatedAt === void 0) return [];
+	const metadata = {};
+	if (update.title !== void 0) metadata.title = update.title;
+	if (update.updatedAt !== void 0) metadata.updatedAt = update.updatedAt;
+	return [{
+		type: "conversation.metadata.updated",
+		update: metadata
+	}];
+}
+//#endregion
+//#region src/infrastructure/acp/error.ts
+/** A request from the ACP agent cannot be completed by the Host. */
+var AcpClientRequestError = class extends h("AcpClientRequestError") {
+	constructor(args) {
+		super({
+			...args,
+			data: args.data,
+			classification: "terminal"
+		});
+	}
+};
+/** The ACP agent process could not start. */
+var AcpStartError = class extends h("AcpStartError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "ACP agent process could not start",
+			classification: "terminal"
+		});
+	}
+};
+/** An ACP request returned a JSON-RPC error. */
+var AcpRpcError = class extends h("AcpRpcError") {
+	constructor(args) {
+		super({
+			...args,
+			message: args.rpc.message,
+			classification: "terminal"
+		});
+	}
+};
+/** The ACP agent process exited before a request finished. */
+var AcpExitedError = class extends h("AcpExitedError") {
+	constructor(args) {
+		super({
+			...args,
+			message: `ACP agent process exited ${String(args.code)}`,
+			classification: "transient"
+		});
+	}
+};
+/** The ACP process connection failed for a reason other than exit or timeout. */
+var AcpProcessError = class extends h("AcpProcessError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "ACP process connection failed",
+			classification: "transient"
+		});
+	}
+};
+/** An ACP request did not finish before its deadline. */
+var AcpTimeoutError = class extends h("AcpTimeoutError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "ACP request timed out",
+			classification: "transient"
+		});
+	}
+};
+/** The ACP agent selected a protocol version that this client does not implement. */
+var AcpProtocolVersionMismatchError = class extends h("AcpProtocolVersionMismatchError") {
+	constructor(args) {
+		super({
+			...args,
+			message: `ACP protocol version ${String(args.received)} is not supported`,
+			classification: "terminal"
+		});
+	}
+};
+//#endregion
+//#region src/infrastructure/acp/incoming-request.ts
+const permissionOptionSchema = object({
+	optionId: string().min(1),
+	name: string().min(1),
+	kind: _enum([
+		"allow_once",
+		"allow_always",
+		"reject_once",
+		"reject_always"
+	])
+});
+const permissionParamsSchema = object({
+	sessionId: string().min(1),
+	toolCall: object({
+		toolCallId: ToolCallIdSchema,
+		title: string().nullable().optional()
+	}),
+	options: array(permissionOptionSchema)
+});
+const elicitationPropertySchema = discriminatedUnion("type", [
+	object({
+		type: literal("string"),
+		title: string().nullish(),
+		enum: array(string()).min(1).optional()
+	}),
+	object({
+		type: literal("number"),
+		title: string().nullish()
+	}),
+	object({
+		type: literal("integer"),
+		title: string().nullish()
+	}),
+	object({
+		type: literal("boolean"),
+		title: string().nullish()
+	})
+]);
+const elicitationParamsSchema = discriminatedUnion("mode", [object({
+	mode: literal("form"),
+	sessionId: string().min(1),
+	requestedSchema: object({
+		properties: record(string(), elicitationPropertySchema),
+		required: array(string()).nullish()
+	})
+}), object({
+	mode: literal("url"),
+	sessionId: string().min(1),
+	elicitationId: string().min(1),
+	url: httpUrl()
+})]);
+const readFileParamsSchema = object({
+	path: string().min(1),
+	line: number().optional(),
+	limit: number().optional()
+});
+const writeFileParamsSchema = object({
+	path: string().min(1),
+	content: string()
+});
+/** Answer one JSON-RPC request from the ACP agent. */
+async function answerIncomingRequest(cwd, method, params) {
+	if (method === "fs/read_text_file") return readTextFile(cwd, params);
+	if (method === "fs/write_text_file") return writeTextFile(cwd, params);
+	throw new AcpClientRequestError({
+		code: -32601,
+		message: `method not found: ${method}`
+	});
+}
+/** Parse one ACP permission request at the Grok boundary. */
+function parsePermissionRequest(params) {
+	const parsed = permissionParamsSchema.safeParse(params);
+	if (!parsed.success) throw new AcpClientRequestError({
+		code: -32602,
+		message: "invalid session/request_permission params"
+	});
+	return parsed.data;
+}
+/** Parse the supported ACP elicitation subset at the Grok boundary. */
+function parseElicitationRequest(params) {
+	const parsed = elicitationParamsSchema.safeParse(params);
+	if (!parsed.success) throw new AcpClientRequestError({
+		code: -32602,
+		message: "invalid elicitation/create params"
+	});
+	if (parsed.data.mode === "url") return {
+		sessionId: parsed.data.sessionId,
+		elicitationId: parsed.data.elicitationId,
+		request: {
+			type: "url",
+			url: parsed.data.url
+		}
+	};
+	const required = new Set(parsed.data.requestedSchema.required ?? []);
+	const fields = Object.entries(parsed.data.requestedSchema.properties).map(([id, property]) => {
+		const label = property.title ?? id;
+		if (property.type === "string") return property.enum === void 0 ? {
+			type: "text",
+			id,
+			label,
+			required: required.has(id)
+		} : {
+			type: "text",
+			id,
+			label,
+			required: required.has(id),
+			options: property.enum
+		};
+		if (property.type === "boolean") return {
+			type: "boolean",
+			id,
+			label,
+			required: required.has(id)
+		};
+		return {
+			type: "number",
+			id,
+			label,
+			required: required.has(id)
+		};
+	});
+	if (fields.length === 0) throw new AcpClientRequestError({
+		code: -32602,
+		message: "elicitation form has no supported fields"
+	});
+	return {
+		sessionId: parsed.data.sessionId,
+		request: {
+			type: "form",
+			fields
+		}
+	};
+}
+async function readTextFile(cwd, params) {
+	const parsed = readFileParamsSchema.safeParse(params);
+	if (!parsed.success) throw new AcpClientRequestError({
+		code: -32602,
+		message: "invalid fs/read_text_file params"
+	});
+	const path = resolveConversationPath(cwd, parsed.data.path);
+	try {
+		return { content: sliceLines(await readFile(path, "utf8"), parsed.data.line, parsed.data.limit) };
+	} catch (cause) {
+		throw new AcpClientRequestError({
+			code: -32e3,
+			message: fileErrorMessage(cause)
+		});
+	}
+}
+async function writeTextFile(cwd, params) {
+	const parsed = writeFileParamsSchema.safeParse(params);
+	if (!parsed.success) throw new AcpClientRequestError({
+		code: -32602,
+		message: "invalid fs/write_text_file params"
+	});
+	const path = resolveConversationPath(cwd, parsed.data.path);
+	try {
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, parsed.data.content);
+		return {};
+	} catch (cause) {
+		throw new AcpClientRequestError({
+			code: -32e3,
+			message: fileErrorMessage(cause)
+		});
+	}
+}
+function resolveConversationPath(cwd, requestedPath) {
+	const root = resolve(cwd);
+	const path = resolve(root, requestedPath);
+	const fromRoot = relative(root, path);
+	if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) throw new AcpClientRequestError({
+		code: -32602,
+		message: "path is outside the conversation directory"
+	});
+	return path;
+}
+function sliceLines(raw, line, limit) {
+	if (line === void 0 && limit === void 0) return raw;
+	const lines = raw.split("\n");
+	const start = line === void 0 ? 0 : Math.max(line - 1, 0);
+	const end = limit === void 0 ? lines.length : start + limit;
+	return lines.slice(start, end).join("\n");
+}
+function fileErrorMessage(cause) {
+	if (cause instanceof Error) return cause.message;
+	return "file operation failed";
+}
+//#endregion
+//#region src/infrastructure/acp/acp-coding-agent.ts
+/** A turn may run tools for a long time; the relay cancels, the host does not time out. */
+const PROMPT_TIMEOUT_MS = 18e5;
+const sessionIdParamsSchema = object({ sessionId: ConversationIdSchema });
+/**
+* `CodingAgent` over one ACP process.
+*
+* Keeps only what ACP needs: the sessions this process opened (`cwd` for fs
+* requests, one mapper each) and the client requests parked until the relay
+* answers them. Turn state and transcripts belong to the `Conversation` aggregate.
+*/
+var AcpCodingAgent = class AcpCodingAgent {
+	agent;
+	listener;
+	sessions = /* @__PURE__ */ new Map();
+	parkedPermissions = /* @__PURE__ */ new Map();
+	parkedElicitations = /* @__PURE__ */ new Map();
+	elicitationOwners = /* @__PURE__ */ new Map();
+	/** Updates for a session whose `session/new` response has not arrived yet. */
+	orphans = /* @__PURE__ */ new Map();
+	constructor(agent, listener) {
+		this.agent = agent;
+		this.listener = listener;
+	}
+	/** Start the agent with this adapter's inbound callbacks wired in. */
+	static async start(launch, listener) {
+		let adapter;
+		const ready = await launch({
+			onUpdate: (notification) => adapter?.receiveUpdate(notification),
+			onRequest: (id, method, params) => {
+				if (adapter === void 0) throw new AcpClientRequestError({
+					code: -32603,
+					message: "agent is starting"
+				});
+				return adapter.answerRequest(id, method, params);
+			},
+			onElicitationComplete: ({ elicitationId: id }) => adapter?.completeElicitation(id)
+		});
+		adapter = new AcpCodingAgent(ready, listener);
+		return adapter;
+	}
+	async listSessions(cursor) {
+		const listed = await this.agent.process.request({
+			method: "session/list",
+			params: cursor === void 0 ? {} : { cursor }
+		});
+		const sessions = listed.sessions.flatMap((row) => {
+			const facts = this.agent.sessionFacts(row);
+			return facts === void 0 ? [] : [facts];
+		});
+		return listed.nextCursor == null ? { sessions } : {
+			sessions,
+			next: ConversationCursorSchema.parse(listed.nextCursor)
+		};
+	}
+	async createSession(input) {
+		const created = await this.agent.process.request({
+			method: "session/new",
+			params: {
+				cwd: input.cwd,
+				mcpServers: toMcpServers(input.mcpServers)
+			}
+		});
+		const id = ConversationIdSchema.parse(created.sessionId);
+		const session = this.open(id, input.cwd, parseSessionModels(created));
+		return {
+			id,
+			events: [...this.configurationEvents(session), ...this.adoptOrphans(id)]
+		};
+	}
+	async loadSession(id, cwd) {
+		const session = this.open(id, cwd, void 0);
+		session.replay = [];
+		try {
+			const loaded = await this.agent.process.request({
+				method: "session/load",
+				params: {
+					sessionId: id,
+					cwd,
+					mcpServers: []
+				}
+			});
+			session.models = parseSessionModels(loaded);
+			session.contextTokens = this.agent.contextTokens(session.models);
+			return {
+				title: this.agent.sessionTitle(loaded),
+				events: [...session.replay, ...this.configurationEvents(session)]
+			};
+		} catch (cause) {
+			this.sessions.delete(id);
+			throw cause;
+		} finally {
+			session.replay = void 0;
+		}
+	}
+	isOpen(id) {
+		return this.sessions.has(id);
+	}
+	async prompt(id, turnId, promptIndex, content) {
+		const session = this.requireSession(id);
+		session.mapper.beginTurn(turnId, promptIndex);
+		try {
+			const response = await this.agent.process.request({
+				method: "session/prompt",
+				params: {
+					sessionId: id,
+					prompt: content.map(toAcpContent)
+				},
+				timeoutMs: PROMPT_TIMEOUT_MS
+			});
+			const usage = this.agent.promptUsage(response._meta, session.contextTokens);
+			return usage === void 0 ? { outcome: toOutcome(response.stopReason) } : {
+				outcome: toOutcome(response.stopReason),
+				usage
+			};
+		} finally {
+			this.listener.onEvents(id, session.mapper.endTurn());
+		}
+	}
+	async cancel(id) {
+		this.requireSession(id);
+		if (this.agent.process.exited) return;
+		await this.agent.process.notify({
+			method: "session/cancel",
+			params: { sessionId: id }
+		});
+	}
+	async setModel(id, modelId) {
+		const session = this.requireSession(id);
+		await this.agent.process.request({
+			method: "session/set_model",
+			params: {
+				sessionId: id,
+				modelId
+			}
+		});
+		if (session.models === void 0) return [];
+		session.models = {
+			...session.models,
+			currentModelId: modelId
+		};
+		session.contextTokens = this.agent.contextTokens(session.models);
+		return this.configurationEvents(session);
+	}
+	async closeSession(id) {
+		if (this.sessions.get(id) === void 0) return;
+		this.sessions.delete(id);
+		this.orphans.delete(id);
+		this.releaseParked(id);
+		if (this.agent.capabilities.sessionCapabilities?.close == null) return;
+		if (this.agent.process.exited) return;
+		await this.agent.process.request({
+			method: "session/close",
+			params: { sessionId: id }
+		});
+	}
+	resolvePermission(id, outcome) {
+		const parked = this.parkedPermissions.get(id);
+		if (parked === void 0) return;
+		this.parkedPermissions.delete(id);
+		parked.resolve(outcome.type === "selected" ? { outcome: {
+			outcome: "selected",
+			optionId: outcome.optionId
+		} } : { outcome: { outcome: "cancelled" } });
+	}
+	resolveElicitation(id, answer) {
+		const parked = this.parkedElicitations.get(id);
+		if (parked === void 0) return;
+		this.parkedElicitations.delete(id);
+		if (answer.type !== "accept") this.elicitationOwners.delete(id);
+		parked.resolve(elicitationResponse(answer));
+	}
+	async stop() {
+		for (const id of this.sessions.keys()) this.releaseParked(id);
+		this.sessions.clear();
+		await this.agent.process.stop();
+	}
+	open(id, cwd, models) {
+		const session = {
+			cwd,
+			mapper: new AcpUpdateMapper(id),
+			models,
+			contextTokens: this.agent.contextTokens(models),
+			replay: void 0
+		};
+		this.sessions.set(id, session);
+		return session;
+	}
+	requireSession(id) {
+		const session = this.sessions.get(id);
+		if (session === void 0) throw new ConversationNotFoundError();
+		return session;
+	}
+	configurationEvents(session) {
+		if (session.models === void 0) return [];
+		return [{
+			type: "conversation.configuration.updated",
+			options: [modelsToConfiguration(session.models)]
+		}];
+	}
+	receiveUpdate(notification) {
+		const id = ConversationIdSchema.safeParse(notification.sessionId);
+		if (!id.success) return;
+		const session = this.sessions.get(id.data);
+		if (session === void 0) {
+			const pending = this.orphans.get(id.data) ?? [];
+			pending.push(notification);
+			this.orphans.set(id.data, pending);
+			return;
+		}
+		const events = session.mapper.map(notification);
+		if (session.replay !== void 0) session.replay.push(...events);
+		else if (events.length > 0) this.listener.onEvents(id.data, events);
+	}
+	adoptOrphans(id) {
+		const pending = this.orphans.get(id) ?? [];
+		this.orphans.delete(id);
+		const session = this.requireSession(id);
+		return pending.flatMap((notification) => session.mapper.map(notification));
+	}
+	answerRequest = async (requestId, method, params) => {
+		const parsed = sessionIdParamsSchema.safeParse(params);
+		const session = parsed.success ? this.sessions.get(parsed.data.sessionId) : void 0;
+		if (!parsed.success || session === void 0) throw new AcpClientRequestError({
+			code: -32602,
+			message: "unknown session"
+		});
+		if (requestId === null) throw new AcpClientRequestError({
+			code: -32600,
+			message: "request has no id"
+		});
+		const conversationId = parsed.data.sessionId;
+		if (method === "session/request_permission") return this.parkPermission(conversationId, session, requestId, params);
+		if (method === "elicitation/create") return this.parkElicitation(conversationId, session, requestId, params);
+		return answerIncomingRequest(session.cwd, method, params);
+	};
+	parkPermission(conversationId, session, requestId, params) {
+		const request = parsePermissionRequest(params);
+		const turnId = session.mapper.liveTurnId;
+		if (turnId === void 0) throw new AcpClientRequestError({
+			code: -32600,
+			message: "no active turn"
+		});
+		const id = permissionId(turnId, requestId);
+		const parked = new Promise((resolve) => {
+			this.parkedPermissions.set(id, {
+				conversationId,
+				resolve
+			});
+		});
+		this.listener.onPermissionRequest(conversationId, {
+			permissionId: id,
+			toolCallId: request.toolCall.toolCallId,
+			title: request.toolCall.title ?? "",
+			options: request.options
+		});
+		return parked;
+	}
+	parkElicitation(conversationId, session, requestId, params) {
+		const request = parseElicitationRequest(params);
+		const turnId = session.mapper.liveTurnId;
+		if (turnId === void 0) throw new AcpClientRequestError({
+			code: -32600,
+			message: "no active turn"
+		});
+		const id = request.elicitationId === void 0 ? elicitationId(turnId, requestId) : ElicitationIdSchema.parse(request.elicitationId);
+		const parked = new Promise((resolve) => {
+			this.parkedElicitations.set(id, {
+				conversationId,
+				resolve
+			});
+		});
+		this.elicitationOwners.set(id, conversationId);
+		this.listener.onElicitationRequest(conversationId, {
+			elicitationId: id,
+			request: request.request
+		});
+		return parked;
+	}
+	completeElicitation(raw) {
+		const id = ElicitationIdSchema.safeParse(raw);
+		if (!id.success) return;
+		const owner = this.elicitationOwners.get(id.data);
+		if (owner === void 0) return;
+		this.elicitationOwners.delete(id.data);
+		this.listener.onElicitationComplete(owner, id.data);
+	}
+	/** Answer every parked request of one session as cancelled so the agent can move on. */
+	releaseParked(conversationId) {
+		for (const [id, parked] of this.parkedPermissions) {
+			if (parked.conversationId !== conversationId) continue;
+			this.parkedPermissions.delete(id);
+			parked.resolve({ outcome: { outcome: "cancelled" } });
+		}
+		for (const [id, parked] of this.parkedElicitations) {
+			if (parked.conversationId !== conversationId) continue;
+			this.parkedElicitations.delete(id);
+			this.elicitationOwners.delete(id);
+			parked.resolve({ action: "cancel" });
+		}
+	}
+};
+function toOutcome(stopReason) {
+	switch (stopReason) {
+		case "end_turn": return {
+			type: "completed",
+			reason: "completed"
+		};
+		case "refusal": return {
+			type: "completed",
+			reason: "refused"
+		};
+		case "max_tokens":
+		case "max_turn_requests": return {
+			type: "completed",
+			reason: "limit_reached"
+		};
+		case "cancelled": return { type: "cancelled" };
+	}
+}
+function elicitationResponse(answer) {
+	if (answer.type === "submit") return {
+		action: "accept",
+		content: answer.values
+	};
+	if (answer.type === "accept") return { action: "accept" };
+	return { action: answer.type };
+}
+function toMcpServers(servers) {
+	if (servers === void 0) return [];
+	return [...servers];
+}
+//#endregion
+//#region src/application/errors/coding-agent-errors.ts
+/** A coding agent does not support a capability required by Porte. */
+var CodingAgentCapabilityError = class extends h("CodingAgentCapabilityError") {
+	constructor(args) {
+		super({
+			...args,
+			message: `Coding agent does not support ${args.capability}`,
+			classification: "terminal"
+		});
+	}
+};
+/** A coding agent returned data that Porte cannot use. */
+var CodingAgentResponseError = class extends h("CodingAgentResponseError") {
+	constructor(args) {
+		super({
+			...args,
+			message: "Coding agent returned an invalid response",
+			classification: "terminal"
+		});
+	}
+};
+//#endregion
+//#region src/infrastructure/acp/acp-agent-process.ts
+/** Deadline for one ACP JSON-RPC request unless the caller passes `timeoutMs`. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+/**
+* One ACP agent process and the JSON-RPC connection to it over stdio.
+*
+* Owns spawn, typed requests with deadlines, inbound ACP client methods, and stop.
+* Does not know which agent binary it runs, or Porte conversations.
+*/
+var AcpAgentProcess = class AcpAgentProcess {
+	child;
+	stdio;
+	stopped = false;
+	abortListener;
+	constructor(child, input) {
+		this.child = child;
+		const app = acp.client({ name: "porte" }).onNotification(acp.methods.client.session.update, ({ params }) => {
+			input.onUpdate(params);
+		}).onNotification(acp.methods.client.elicitation.complete, ({ params }) => {
+			input.onElicitationComplete?.(params);
+		});
+		registerClientRequests(app, input.onRequest);
+		child.stderr.resume();
+		const output = Writable.toWeb(child.stdin);
+		const source = Readable.toWeb(child.stdout);
+		this.stdio = app.connect(acp.ndJsonStream(output, source));
+		this.abortListener = addAbortListener(input.signal, () => {
+			this.stop();
+		});
+	}
+	/**
+	* Spawn one ACP process and wait until the OS has started it.
+	*
+	* @param input - Binary, argv, working directory, host signal, and ACP callbacks.
+	* @returns A live transport, or `AcpStartError` when spawn fails or the host signal is already aborted.
+	*/
+	static async start(input) {
+		if (input.signal.aborted) throw new AcpStartError({ cause: input.signal.reason });
+		const child = spawn(input.command, [...input.args], {
+			cwd: input.cwd,
+			env: process.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		try {
+			await once(child, "spawn", { signal: input.signal });
+		} catch (cause) {
+			child.kill("SIGTERM");
+			throw new AcpStartError({ cause });
+		}
+		return new AcpAgentProcess(child, input);
+	}
+	async request(request) {
+		this.throwIfStopped();
+		const timeoutMs = request.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+		const deadline = new AbortController();
+		const timer = setTimeout(() => {
+			deadline.abort(new AcpTimeoutError({ timeoutMs }));
+		}, timeoutMs);
+		const response = this.stdio.agent.request(request.method, request.params, { cancellationSignal: deadline.signal }).catch((cause) => {
+			throw this.mapRequestError(cause);
+		});
+		const expired = once(deadline.signal, "abort").then(() => {
+			throw deadline.signal.reason;
+		});
+		try {
+			return await Promise.race([response, expired]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	/**
+	* Send one typed ACP notification without waiting for a response.
+	*
+	* @param notification - ACP notification method and params.
+	*/
+	async notify(notification) {
+		this.throwIfStopped();
+		try {
+			await this.stdio.agent.notify(notification.method, notification.params);
+		} catch (cause) {
+			throw new AcpProcessError({ cause });
+		}
+	}
+	/**
+	* Close JSON-RPC and stop the child (SIGTERM, then SIGKILL).
+	*/
+	async stop() {
+		this.abortListener?.[Symbol.dispose]();
+		this.abortListener = void 0;
+		if (this.stopped) return;
+		this.stopped = true;
+		this.stdio.close();
+		if (this.child.exitCode !== null || this.child.signalCode !== null) return;
+		this.child.kill("SIGTERM");
+		if (await exited(this.child, 2e3)) return;
+		this.child.kill("SIGKILL");
+		await exited(this.child, 2e3);
+	}
+	/** True once the child is gone, by our stop or its own exit; every request then fails. */
+	get exited() {
+		return this.stopped || this.child.exitCode !== null || this.child.signalCode !== null;
+	}
+	throwIfStopped() {
+		if (this.exited) throw new AcpExitedError({ code: this.child.exitCode });
+	}
+	mapRequestError(cause) {
+		if (cause instanceof acp.RequestError) return new AcpRpcError({ rpc: cause.toErrorResponse() });
+		if (this.child.exitCode !== null || this.child.signalCode !== null) return new AcpExitedError({ code: this.child.exitCode });
+		return new AcpProcessError({ cause });
+	}
+};
+function registerClientRequests(app, handler) {
+	app.onRequest(acp.methods.client.session.requestPermission, (context) => handleClientRequest(handler, context, acp.methods.client.session.requestPermission)).onRequest(acp.methods.client.fs.readTextFile, (context) => handleClientRequest(handler, context, acp.methods.client.fs.readTextFile)).onRequest(acp.methods.client.fs.writeTextFile, (context) => handleClientRequest(handler, context, acp.methods.client.fs.writeTextFile)).onRequest(acp.methods.client.terminal.create, (context) => handleClientRequest(handler, context, acp.methods.client.terminal.create)).onRequest(acp.methods.client.terminal.output, (context) => handleClientRequest(handler, context, acp.methods.client.terminal.output)).onRequest(acp.methods.client.terminal.release, (context) => handleClientRequest(handler, context, acp.methods.client.terminal.release)).onRequest(acp.methods.client.terminal.waitForExit, (context) => handleClientRequest(handler, context, acp.methods.client.terminal.waitForExit)).onRequest(acp.methods.client.terminal.kill, (context) => handleClientRequest(handler, context, acp.methods.client.terminal.kill)).onRequest(acp.methods.client.elicitation.create, (context) => handleClientRequest(handler, context, acp.methods.client.elicitation.create));
+}
+async function handleClientRequest(handler, context, method) {
+	const params = json().safeParse(context.params);
+	if (!params.success) throw acp.RequestError.invalidParams(params.error, "Invalid JSON params");
+	try {
+		return await handler(context.requestId, method, params.data);
+	} catch (cause) {
+		if (cause instanceof AcpClientRequestError) throw new acp.RequestError(cause.code, cause.message, cause.data);
+		throw cause;
+	}
+}
+/** True when the child has exited within `timeoutMs`. */
+function exited(child, timeoutMs) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
+	return once(child, "exit", { signal: AbortSignal.timeout(timeoutMs) }).then(() => true, () => false);
+}
+//#endregion
+//#region src/infrastructure/grok/grok-launch.ts
+/** Grok lists sessions with the repository under `_meta['x.ai/session'].facets.gitRoot`. */
+const grokSessionSchema = object({
+	sessionId: ConversationIdSchema,
+	cwd: string().min(1),
+	title: string().optional(),
+	updatedAt: IsoDateTimeSchema,
+	_meta: object({ "x.ai/session": object({ facets: object({ gitRoot: string().min(1).optional() }) }).optional() }).optional()
+});
+/** Parse one Grok `session/list` row into session facts; rows with no git root are skipped. */
+function toSessionFacts(session) {
+	const parsed = grokSessionSchema.safeParse(session);
+	if (!parsed.success) throw new CodingAgentResponseError({ cause: parsed.error });
+	const gitRoot = parsed.data._meta?.["x.ai/session"]?.facets.gitRoot;
+	if (gitRoot === void 0) return void 0;
+	return {
+		id: parsed.data.sessionId,
+		cwd: parsed.data.cwd,
+		gitRoot: normaliseGitRoot(gitRoot),
+		title: parsed.data.title ?? "",
+		updatedAt: parsed.data.updatedAt
+	};
+}
+const GROK_CACHED_TOKEN_AUTH_METHOD_ID = "cached_token";
+/** Grok reports the context size on each model's `_meta` (spike: `totalContextTokens`). */
+const modelMetaSchema = object({ totalContextTokens: number().int().positive() });
+/** Grok reports the tokens the last call used on the prompt response `_meta` (spike). */
+const promptMetaSchema = object({ totalTokens: number().int().nonnegative() });
+/**
+* Start Grok as one ACP process: spawn, `initialize`, `cached_token` auth, capability
+* check. Runs once at `porte up`; the adapter owns the returned process from then on.
+*
+* @throws CodingAgentUnavailableError when the process cannot start or the signal is aborted.
+* @throws CodingAgentCapabilityError when Grok lacks `session/list` or `session/load`.
+*/
+async function startGrok(signal, callbacks) {
+	const process = await AcpAgentProcess.start({
+		command: "grok",
+		args: [
+			"--no-auto-update",
+			"agent",
+			"stdio"
+		],
+		cwd: homedir(),
+		signal,
+		...callbacks
+	}).catch((cause) => {
+		throw new CodingAgentUnavailableError({ cause });
+	});
+	try {
+		const initialized = await process.request({
+			method: "initialize",
+			params: {
+				protocolVersion: PROTOCOL_VERSION,
+				clientCapabilities: {
+					fs: {
+						readTextFile: true,
+						writeTextFile: true
+					},
+					elicitation: {
+						form: {},
+						url: {}
+					},
+					plan: {}
+				},
+				clientInfo: {
+					name: "porte",
+					title: "Porte",
+					version: "0.1.0"
+				}
+			}
+		});
+		if (initialized.protocolVersion !== PROTOCOL_VERSION) throw new AcpProtocolVersionMismatchError({
+			expected: PROTOCOL_VERSION,
+			received: initialized.protocolVersion
+		});
+		await authenticate(process, initialized.authMethods);
+		const capabilities = initialized.agentCapabilities ?? {};
+		requireCapabilities(capabilities);
+		return {
+			process,
+			capabilities,
+			sessionFacts: toSessionFacts,
+			sessionTitle,
+			contextTokens,
+			promptUsage
+		};
+	} catch (cause) {
+		await process.stop();
+		throw cause;
+	}
+}
+async function authenticate(process, methods) {
+	const cachedToken = methods?.find((method) => !("type" in method) && method.id === GROK_CACHED_TOKEN_AUTH_METHOD_ID);
+	if (cachedToken === void 0) return;
+	await process.request({
+		method: "authenticate",
+		params: {
+			methodId: cachedToken.id,
+			_meta: { headless: true }
+		}
+	});
+}
+function requireCapabilities(capabilities) {
+	if (capabilities.sessionCapabilities?.list == null) throw new CodingAgentCapabilityError({
+		capability: "conversation.list",
+		cause: /* @__PURE__ */ new TypeError("Grok does not advertise ACP sessionCapabilities.list")
+	});
+	if (capabilities.loadSession !== true) throw new CodingAgentCapabilityError({
+		capability: "conversation.open",
+		cause: /* @__PURE__ */ new TypeError("Grok does not advertise ACP loadSession")
+	});
+}
+/** Grok puts the list title on the load response under `_meta['x.ai/sessionDetail']` (capture). */
+const sessionDetailSchema = object({ "x.ai/sessionDetail": object({ title: string().optional() }).optional() });
+function sessionTitle(response) {
+	const parsed = sessionDetailSchema.safeParse(response._meta);
+	return parsed.success ? parsed.data["x.ai/sessionDetail"]?.title ?? "" : "";
+}
+function contextTokens(models) {
+	const current = models?.availableModels.find((model) => model.modelId === models.currentModelId);
+	const meta = modelMetaSchema.safeParse(current?._meta);
+	return meta.success ? meta.data.totalContextTokens : void 0;
+}
+function promptUsage(meta, sizeTokens) {
+	const parsed = promptMetaSchema.safeParse(meta);
+	if (!parsed.success || sizeTokens === void 0) return void 0;
+	return {
+		usedTokens: Math.min(parsed.data.totalTokens, sizeTokens),
+		sizeTokens
+	};
+}
+//#endregion
+//#region src/infrastructure/node/background-tasks.ts
+const logger$1 = createLogger("background-tasks");
+var NodeBackgroundTasks = class {
+	pending = /* @__PURE__ */ new Set();
+	run(task) {
+		const tracked = task.catch((cause) => {
+			logger$1.error("background_task_failed", { error: cause });
+		}).finally(() => {
+			this.pending.delete(tracked);
+		});
+		this.pending.add(tracked);
+	}
+	async drain() {
+		await Promise.allSettled(this.pending);
+	}
+};
+//#endregion
+//#region src/infrastructure/node/scheduler.ts
+/** Node timers, unref'd so a pending deadline never blocks shutdown. */
+var NodeScheduler = class {
+	schedule(delayMs, task) {
+		setTimeout(task, delayMs).unref();
+	}
+};
+//#endregion
+//#region src/infrastructure/persistence/event-outbox.ts
+/**
+* In-memory outbox. Repositories push the events an aggregate raised on `save`;
+* the message bus drains it after every handler, so events run after the writes.
+*/
+var EventOutbox = class {
+	pending = [];
+	push(events) {
+		this.pending.push(...events);
+	}
+	/** Every event pushed since the last drain, in push order. */
+	drain() {
+		const drained = this.pending;
+		this.pending = [];
+		return drained;
+	}
+};
+//#endregion
+//#region src/domain/conversation/conversation-errors.ts
+/** The conversation is already open on this process; open it once. */
+var ConversationAlreadyOpenError = class extends h("ConversationAlreadyOpenError") {
+	constructor() {
+		super({
+			message: "Conversation is already open.",
+			classification: "terminal"
+		});
+	}
+};
+//#endregion
+//#region src/infrastructure/persistence/in-memory-conversation-repository.ts
+var InMemoryConversationRepository = class {
+	outbox;
+	rows = /* @__PURE__ */ new Map();
+	constructor(outbox) {
+		this.outbox = outbox;
+	}
+	find(id) {
+		return this.rows.get(id) ?? null;
+	}
+	get(id) {
+		const conversation = this.rows.get(id);
+		if (conversation === void 0) throw new ConversationNotFoundError();
+		return conversation;
+	}
+	insert(conversation) {
+		if (this.rows.has(conversation.id)) throw new ConversationAlreadyOpenError();
+		this.rows.set(conversation.id, conversation);
+		this.publish(conversation);
+	}
+	save(conversation) {
+		if (!this.rows.has(conversation.id)) throw new ConversationNotFoundError();
+		this.publish(conversation);
+	}
+	delete(conversation) {
+		this.rows.delete(conversation.id);
+		this.publish(conversation);
+	}
+	all() {
+		return [...this.rows.values()];
+	}
+	publish(conversation) {
+		this.outbox.push(conversation.collectEvents());
+		conversation.clearEvents();
+	}
+};
+//#endregion
+//#region src/infrastructure/websocket/party-socket-transport.ts
+const logger = createLogger("party-socket-transport");
+const PING_INTERVAL_MS = 3e4;
+const InboundMessageSchema = object({ data: unknown() });
+const InboundCloseSchema = object({
+	code: number(),
+	reason: string()
+});
+const InboundErrorSchema = object({
+	error: unknown().optional(),
+	message: string().optional()
+});
+/** Own one authenticated PartySocket and all WebSocket lifecycle work. */
+var PartySocketTransport = class {
+	input;
+	stoppedState = Promise.withResolvers();
+	socket;
+	listeners;
+	closed = false;
+	handshake;
+	up = Promise.resolve();
+	/** Settles once, when this socket will not come back. */
+	stopped = this.stoppedState.promise;
+	constructor(input, socket) {
+		this.input = input;
+		this.socket = socket ?? this.createSocket();
+	}
+	/** Attach listeners and start connecting. Does not wait for open. */
+	start(listeners) {
+		this.listeners = listeners;
+		logger.debug("websocket_connecting", {
+			url: this.input.url,
+			subprotocol: this.input.subprotocol
+		});
+		listeners.onStatus?.({ type: "connecting" });
+		this.socket.addEventListener("open", this.onOpen);
+		this.socket.addEventListener("message", this.onMessage);
+		this.socket.addEventListener("error", this.onError);
+		this.socket.addEventListener("close", this.onClose);
+		this.socket.reconnect();
+	}
+	/** Send one text frame. Retries only when the socket did not accept it. */
+	async send(frame) {
+		await sendJsonRpcFrame(() => this.socket.send(frame));
+	}
+	/** Stop reconnects and close locally. */
+	stop() {
+		this.closed = true;
+		this.socket.close(1e3, "Host connection closed");
+		this.stoppedState.resolve();
+	}
+	createSocket() {
+		const AuthenticatedWebSocket = authenticatedWebSocketConstructor(this.input.authorization, this.recordHandshake);
+		return new WebSocket(this.input.url, this.input.subprotocol, {
+			WebSocket: AuthenticatedWebSocket,
+			maxEnqueuedMessages: 0,
+			startClosed: true,
+			shouldReconnectOnClose: this.shouldReconnect
+		});
+	}
+	onOpen = () => {
+		if (this.closed) return;
+		logger.debug("websocket_connected", { details: {
+			url: this.input.url,
+			retryCount: this.socket.retryCount
+		} });
+		this.listeners?.onStatus?.({
+			type: "connected",
+			attempt: this.socket.retryCount
+		});
+		const onUp = this.listeners?.onUp;
+		this.up = onUp === void 0 ? Promise.resolve() : onUp().catch((cause) => {
+			this.fail(new WebSocketHandlerError({ cause }));
+		});
+	};
+	onMessage = (event) => {
+		if (this.closed) return;
+		const message = InboundMessageSchema.safeParse(event);
+		const parsed = readJsonRpcTextFrame(JsonRpcTextSchema.safeParse(message.success ? message.data.data : void 0));
+		if (!parsed.ok) {
+			logger.warn("websocket_frame_rejected", { details: parsed.close });
+			this.socket.close(parsed.close.code, parsed.close.reason);
+			return;
+		}
+		this.deliverFrame(parsed.frame);
+	};
+	onError = (event) => {
+		if (this.closed) return;
+		const parsed = InboundErrorSchema.safeParse(event);
+		logger.debug("websocket_error", {
+			url: this.input.url,
+			retryCount: this.socket.retryCount,
+			message: parsed.success ? readErrorMessage(parsed.data) : void 0
+		});
+	};
+	onClose = (event) => {
+		if (this.closed) return;
+		const handshake = this.handshake;
+		this.handshake = void 0;
+		if (handshake !== void 0 && !handshake.retry) {
+			this.fail(handshake.error);
+			return;
+		}
+		const closed = InboundCloseSchema.safeParse(event);
+		const code = closed.success ? closed.data.code : 1006;
+		const reason = closed.success ? closed.data.reason : "";
+		if (isTerminalCloseCode(code)) {
+			this.fail(new WebSocketProtocolClose({ message: `WebSocket connection closed: ${reason}` }));
+			return;
+		}
+		logger.debug("websocket_reconnecting", {
+			url: this.input.url,
+			retryCount: this.socket.retryCount,
+			handshakeStatus: handshake?.status,
+			closeCode: code,
+			closeReason: reason
+		});
+		this.listeners?.onStatus?.({
+			type: "reconnecting",
+			attempt: this.socket.retryCount + 1,
+			cause: dropCause(handshake?.status)
+		});
+	};
+	async deliverFrame(frame) {
+		await this.up.catch(() => void 0);
+		if (this.closed || this.listeners === void 0) return;
+		try {
+			const document = await this.listeners.onFrame(frame);
+			if (document !== void 0) await this.send(JSON.stringify(document));
+		} catch (cause) {
+			this.fail(cause instanceof JsonRpcSendError ? cause : new WebSocketHandlerError({ cause }));
+		}
+	}
+	recordHandshake = (status) => {
+		this.handshake = shouldRetryHandshake(status) ? {
+			retry: true,
+			status
+		} : {
+			retry: false,
+			status,
+			error: new WebSocketHandshakeRefused({ status })
+		};
+	};
+	shouldReconnect = (event) => {
+		if (this.closed) return false;
+		const handshake = this.handshake;
+		if (handshake !== void 0) return handshake.retry;
+		return !isTerminalCloseCode(event.code);
+	};
+	fail(cause) {
+		this.closed = true;
+		this.socket.close(1011, "WebSocket transport stopped");
+		this.stoppedState.reject(cause);
+	}
+};
+/** Create one configured PartySocket. */
+const createPartySocketTransport = (input) => new PartySocketTransport(input);
+function authenticatedWebSocketConstructor(authorization, recordHandshake) {
+	return class AuthenticatedWebSocket extends WebSocket$1 {
+		heartbeat;
+		constructor(address, protocols) {
+			super(address, protocols ?? [], { headers: { Authorization: authorization } });
+			this.once("unexpected-response", (_request, response) => {
+				recordHandshake(response.statusCode ?? 0);
+				response.resume();
+				this.close();
+			});
+			this.on("open", () => {
+				this.heartbeat = setInterval(() => {
+					if (this.readyState === WebSocket$1.OPEN) this.ping();
+				}, PING_INTERVAL_MS);
+				this.heartbeat.unref();
+			});
+			this.once("close", () => {
+				if (this.heartbeat !== void 0) clearInterval(this.heartbeat);
+				this.heartbeat = void 0;
+			});
+		}
+	};
+}
+/**
+* A 5xx handshake means the relay's edge answered but the app behind it did
+* not (Cloudflare 530 through a tunnel, 502/503 on deploy). Anything else is
+* the network between here and there.
+*/
+function dropCause(handshakeStatus) {
+	return handshakeStatus !== void 0 && handshakeStatus >= 500 ? "server-unreachable" : "connection-lost";
+}
+function isTerminalCloseCode(code) {
+	return code === 1002 || code === 1003 || code === 1007 || code === 1008 || code === 1009;
+}
+function shouldRetryHandshake(status) {
+	return status === 0 || status === 408 || status === 425 || status === 429 || status >= 500 && status <= 599;
+}
+function readErrorMessage(event) {
+	if (event.message !== void 0) return event.message;
+	return event.error instanceof Error ? event.error.message : void 0;
+}
+//#endregion
+//#region src/infrastructure/app-deps.ts
+/**
+* Composition root for `porte up`. Starts Grok eagerly: a host that cannot run
+* its agent should fail here, not on the first turn.
+*
+* The bus, the sockets, and the agent all need `deps`, and `deps` needs them;
+* the getters resolve that after construction. Nothing reads them before `run`.
+*/
+async function createAppDeps(input) {
+	const outbox = new EventOutbox();
+	const deps = {
+		outbox,
+		conversations: new InMemoryConversationRepository(outbox),
+		background: new NodeBackgroundTasks(),
+		scheduler: new NodeScheduler(),
+		now: () => /* @__PURE__ */ new Date(),
+		get bus() {
+			return bus;
+		},
+		get connections() {
+			return connections;
+		},
+		get codingAgent() {
+			return codingAgent;
+		}
+	};
+	const bus = new MessageBus(deps);
+	const connections = new HostConnectionManager({
+		baseUrl: input.credential.baseUrl,
+		token: input.credential.token,
+		controlHandlers: CONTROL_METHOD_HANDLERS,
+		conversationHandlers: CONVERSATION_METHOD_HANDLERS,
+		bus
+	}, createPartySocketTransport);
+	const codingAgent = await AcpCodingAgent.start((callbacks) => startGrok(input.signal, callbacks), createAgentInbound(bus, deps.background));
+	return deps;
+}
+//#endregion
+//#region src/infrastructure/bootstrap/host-runtime.ts
+/** Create one inactive Host runtime: read the pairing, build the app, start the agent. */
+async function createHostRuntime(config, signal) {
+	const credential = await new FileCredentialStore(config.dataDirectory).read();
+	if (credential === null) throw new HostNotPairedError();
+	return {
+		runtime: new HostRuntime(signal, await createAppDeps({
+			credential,
+			signal
+		})),
+		relayUrl: credential.baseUrl
+	};
+}
+//#endregion
+//#region src/entrypoints/cli/run-up-command.ts
+/** Run the Host until the process receives a shutdown signal. */
+async function runUpCommand(input) {
+	const output = createOutput(input.stderr);
+	const shutdown = new AbortController();
+	const stop = () => {
+		shutdown.abort();
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	try {
+		const { runtime, relayUrl } = await createHostRuntime(input.config, shutdown.signal);
+		await runtime.run(reportRelayStatus(output, relayUrl));
+		if (shutdown.signal.aborted) output.done("Stopped.");
+	} finally {
+		shutdown.abort();
+		process.removeListener("SIGINT", stop);
+		process.removeListener("SIGTERM", stop);
+	}
+}
+/**
+* Turn socket states into the lines a person watches. A drop is one line that
+* rewrites itself on each retry; a terminal failure never reaches here, the
+* CLI error boundary prints it.
+*/
+function reportRelayStatus(output, baseUrl) {
+	const { url, quiet } = output.emphasis;
+	const site = new URL(baseUrl).host;
+	let wasConnected = false;
+	return (status) => {
+		switch (status.type) {
+			case "connecting":
+				output.status(quiet(`Connecting to ${site}…`));
+				return;
+			case "connected":
+				if (wasConnected) output.done("Reconnected.");
+				else {
+					output.done(`Connected. Open ${url(`${baseUrl}/conversations`)}`);
+					wasConnected = true;
+				}
+				return;
+			case "reconnecting":
+				output.status(`${DROP_TEXT[status.cause]} ${quiet(`Retrying (attempt ${String(status.attempt)})…`)}`);
+				return;
+		}
+	};
+}
+/** The relay's edge answered but Porte did not, versus nothing answered at all. */
+const DROP_TEXT = {
+	"server-unreachable": "! Porte is unreachable.",
+	"connection-lost": "! Connection lost."
+};
+//#endregion
+//#region src/entrypoints/cli/unpair-command.ts
+/** Revoke and remove this machine's stored credential. */
+async function runUnpairCommand(input) {
+	const resources = createPairingResources(input.config);
+	const output = createOutput(input.stderr);
+	const stored = await resources.credentials.read();
+	if (stored === null) {
+		output.done("This Mac is not paired.");
+		return 0;
+	}
+	await resources.authorizer.revoke(stored.token);
+	await resources.credentials.clear();
+	output.done(`Unpaired this Mac from ${output.emphasis.strong(new URL(stored.baseUrl).host)}`);
+	return 0;
+}
+//#endregion
+//#region src/entrypoints/cli/run-cli.ts
+/** Run one CLI invocation and report each final error once. */
+async function run(argv, io) {
+	const args = argv[0] === "--" ? argv.slice(1) : argv;
+	try {
+		return await dispatch(args, io);
+	} catch (cause) {
+		if (isCliError(cause)) return reportCliError(io.stderr, cause);
+		return reportUnexpectedCliError(io.stderr, cause);
+	}
+}
+async function dispatch(argv, io) {
+	const command = parseCommand(argv);
+	if (command.kind === "help") {
+		io.stdout.write(`${command.text}\n`);
+		return 0;
+	}
+	if (command.kind === "version") {
+		io.stdout.write(`${VERSION}\n`);
+		return 0;
+	}
+	const config = loadConfig(io.env);
+	if (command.kind === "up") {
+		await runUpCommand({
+			config,
+			stderr: io.stderr
+		});
+		return 0;
+	}
+	if (command.kind === "pair") return runPairCommand({
+		config,
+		stderr: io.stderr
+	});
+	return runUnpairCommand({
+		config,
+		stderr: io.stderr
+	});
+}
+//#endregion
+export { run };