@dev.fast/whiteboard 0.2.5-preview.20261013.113 → 0.2.5-preview.20261015.116

package/dist/server/desktop-host.js

@@ -1,32 +1,94 @@
 #!/usr/bin/env node
-import { C as ReviewInputError, a as diffFileSummaries, b as resolveRevision, i as diff, x as splitGitPatchFiles } from "../src-DiHP11l3.js";
+import { S as splitGitPatchFiles, a as diff, o as diffFileSummaries } from "../src-BMPuxWv4.js";
 import { c as jsonString, i as jsonBoolean, n as isJsonObject, p as isObjectValue, s as jsonProperty, u as parseJsonText } from "../src-X9phtB2j.js";
-import { i as SharedReviewStore } from "../client-DzcSt6pV.js";
-import { c as ReviewBugReportRequestSchema, l as parseReviewBugReportResponse, o as parseZod, s as ReviewBugReportMetaV2Schema, t as parseReviewCliInstallApplyRequest, v as reviewDiffrSummarizerInputSchema } from "../src-WCbabvdS.js";
-import { et as shellQuote, i as reviewInstanceDiscoveryPath, o as reviewLegacyDiscoveryPath } from "../review-home-paths-Y9mYWkCI.js";
-import { C as resourceReferences, M as lensSchema, p as documentSchema } from "../stored-document-migration-u4L_1VZa.js";
-import { A as devReviewHome, P as writePrivateJsonAtomic } from "../s3-config-CAxhO9u_.js";
-import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "../package-paths-B9PDoAl6.js";
-import { c as reviewInstanceIdentity, t as REVIEW_INSTANCE_ENV } from "../desktop-discovery-Ba3dD5Cn.js";
-import { t as openReviewProfile } from "../profile-tbGWuWHu.js";
-import { r as reviewTelemetryChannel, t as ReviewTelemetry } from "../review-telemetry-CmM6tCbj.js";
-import { o as REVIEW_TELEMETRY_TABS } from "../request-origin-DA4K1qWY.js";
-import { c as removeLegacyReviewSkills, d as skipCliInstall, i as finishCliInstallUpdate, l as resetCliInstall, n as applyCliInstall, r as declineCliInstall, s as removeCliInstall, t as aliasInstallationToAccount, u as resolveCliInstallStatus } from "../account-alias-D0hF0sKk.js";
-import { _ as setDiffrConfigValue, a as serverJson, c as recordClientError, d as HttpJsonError, f as ReviewServerError, g as saveDiffrSummarizer, h as readDiffrConfig, i as createWhiteboardCore, l as createNodeRequestListener, m as migrateDiffrConfig, n as installProcessErrorTelemetry, o as captureSanitizedUiTelemetry, p as GlobalReviewDesktopVerbRelay, r as serverCrashReportPath, s as clientErrorsForSession, t as drainServerCrashReport, u as readBoundedRequestJson, v as testDiffrSummarizer } from "../process-error-telemetry-BCBYp2t4.js";
-import { c as readQuerySchemas } from "../authoring-tools-fdA0RPIT.js";
-import crypto, { createHash, randomBytes, randomUUID } from "node:crypto";
+import { d as StreamLimitError, f as readBoundedStream, i as SharedReviewStore } from "../client-DhZzPePs.js";
+import { A as reviewDiffrSummarizerInputSchema, E as ReviewGatewayHostSchema, T as ReviewConnectRequestSchema, c as ReviewBugReportMetaV2Schema, d as REVIEW_CLIENT_HEADER, f as REVIEW_CLIENT_REMOTE, g as REVIEW_HOST_HEADER, l as ReviewBugReportRequestSchema, r as parseReviewDesktopVerbFrame, s as parseZod, t as parseReviewCliInstallApplyRequest, u as parseReviewBugReportResponse } from "../src-Bgvf1sEN.js";
+import { i as reviewInstanceDiscoveryPath, o as reviewLegacyDiscoveryPath } from "../review-home-paths-zwevIq4I.js";
+import { C as resourceReferences } from "../stored-document-migration-CFOvjRwW.js";
+import { t as ReviewInputError } from "../input-error-OLgB_h31.js";
+import { I as writePrivateJsonAtomic, M as devReviewHome } from "../s3-config-DDWWMh5x.js";
+import { t as errorMessage } from "../error-message-OtiDonty.js";
+import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "../package-paths-BsuI4WUf.js";
+import { _ as reviewInstanceIdentity, u as REVIEW_INSTANCE_ENV } from "../server-discovery-CifQ3yQS.js";
+import { t as openReviewProfile } from "../profile-pAzg7fxC.js";
+import { r as reviewTelemetryChannel, t as ReviewTelemetry } from "../review-telemetry-BqB4CiTD.js";
+import { o as REVIEW_TELEMETRY_TABS } from "../request-origin-DaRIV3cB.js";
+import { C as saveDiffrSummarizer, D as findExecutable, E as cliAskTools, S as readDiffrConfig, T as testDiffrSummarizer, _ as DEFAULT_MAX_REQUEST_BYTES, a as drainServerCrashReport, b as GlobalReviewDesktopVerbRelay, c as answerErrorsAsJson, d as coverageModeSchema, f as captureSanitizedUiTelemetry, g as readBoundedRequestJson, h as createNodeRequestListener, l as createWhiteboardCore, m as recordClientError, o as installProcessErrorTelemetry, p as clientErrorsForSession, r as takeOverServerHome, s as serverCrashReportPath, u as serverJson, v as HttpJsonError, w as setDiffrConfigValue, x as migrateDiffrConfig, y as ReviewServerError } from "../headless-host-CVXTSIlx.js";
+import { c as removeLegacyReviewSkills, d as skipCliInstall, i as finishCliInstallUpdate, l as resetCliInstall, m as ALL_INSTALL_TARGETS, n as applyCliInstall, o as pathShimPath, r as declineCliInstall, s as removeCliInstall, t as aliasInstallationToAccount, u as resolveCliInstallStatus, v as reviewMcpLaunch, y as cursorInstallDeeplink } from "../account-alias-ChZR3RIU.js";
+import { c as readQuerySchemas } from "../authoring-tools-BXKEwhfi.js";
+import crypto, { createHash, randomBytes } from "node:crypto";
 import { z } from "zod";
-import fs, { existsSync } from "node:fs";
-import { chmod, copyFile, cp, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { chmod, copyFile, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import os from "node:os";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { pathToFileURL } from "node:url";
-import { Writable } from "node:stream";
+import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { gzip, gzipSync } from "node:zlib";
 import { createServer } from "node:http";
 import { Hono } from "hono";
+import { Agent, request } from "undici";
+//#region ../review-protocol/src/review-host-status.ts
+const OFFLINE = {
+	status: "offline",
+	label: (alias) => `${alias} offline`,
+	action: "retry"
+};
+const UNUSABLE = {
+	status: "can't be used",
+	label: (alias) => `${alias} can't be used`,
+	action: "settings"
+};
+const STATUS = {
+	online: {
+		status: "online",
+		label: (alias) => alias
+	},
+	connecting: {
+		status: "connecting",
+		label: (alias) => `Connecting to ${alias}…`,
+		busy: true
+	},
+	installing: {
+		status: "installing",
+		label: (alias) => `Installing on ${alias}…`,
+		busy: true
+	},
+	offline: OFFLINE,
+	unreachable: OFFLINE,
+	incompatible: {
+		status: "needs an update",
+		label: (alias) => `${alias} needs an update`,
+		action: "install"
+	},
+	"not-installed": {
+		status: "not installed",
+		label: (alias) => `Whiteboard not installed on ${alias}`,
+		action: "install"
+	},
+	"auth-failed": {
+		status: "can't sign in",
+		label: (alias) => `Can't sign in to ${alias}`,
+		action: "settings"
+	},
+	unsupported: UNUSABLE,
+	duplicate: UNUSABLE
+};
+/** One wording and one next step per host state, shared by every surface. */
+function reviewHostStatus(host) {
+	const { label, ...rest } = STATUS[host.state];
+	const words = label(host.alias);
+	return {
+		...rest,
+		label: words,
+		sentence: host.detail ?? (words.endsWith("…") ? words : `${words}.`)
+	};
+}
+//#endregion
 //#region src/review-bundled-tools.ts
 function reviewToolsRoot(env = process.env) {
 	return path.join(devReviewHome(env), "review-tools");
@@ -164,7 +226,11 @@ async function hashFile(filePath) {
 }
 //#endregion
 //#region src/server/desktop-host-shutdown.ts
-function listenForDesktopHostShutdown(hostProcess, onShutdown, onTelemetrySetting, onStageRustAnalyzer) {
+function postToDesktop(hostProcess, message) {
+	if (hostProcess.parentPort?.postMessage) hostProcess.parentPort.postMessage(message);
+	else hostProcess.send?.(message);
+}
+function listenForDesktopHostShutdown(hostProcess, onShutdown, onTelemetrySetting, onStageRustAnalyzer, onRemoteHosts) {
 	const handleMessage = (message) => {
 		if (!isJsonObject(message)) return;
 		const type = jsonProperty(message, "type");
@@ -180,6 +246,11 @@ function listenForDesktopHostShutdown(hostProcess, onShutdown, onTelemetrySettin
 		if (type === "stage-rust-analyzer") {
 			const path = jsonString(jsonProperty(message, "path"));
 			if (path) onStageRustAnalyzer?.(path);
+			return;
+		}
+		if (type === "remote-hosts") {
+			const hosts = ReviewGatewayHostSchema.array().safeParse(jsonProperty(message, "hosts"));
+			if (hosts.success) onRemoteHosts?.(hosts.data);
 		}
 	};
 	if (hostProcess.parentPort) {
@@ -193,6 +264,332 @@ function listenForDesktopHostShutdown(hostProcess, onShutdown, onTelemetrySettin
 	return () => hostProcess.off("message", handleMessage);
 }
 //#endregion
+//#region src/agent-connect.ts
+const MARKETPLACE = "devdotfast/whiteboard";
+const PLUGIN = "whiteboard@devfast";
+const STEP_TIMEOUT_MS = 12e4;
+const HARNESSES = {
+	claude: {
+		name: "Claude Code",
+		commands: ["claude"],
+		installDirs: [".claude/local", ".local/bin"]
+	},
+	codex: {
+		name: "Codex",
+		commands: ["codex"]
+	},
+	cursor: {
+		name: "Cursor",
+		commands: ["cursor"],
+		homeDir: ".cursor",
+		apps: ["/Applications/Cursor.app"]
+	},
+	opencode: {
+		name: "OpenCode",
+		commands: ["opencode"],
+		installDirs: [".opencode/bin"]
+	},
+	pi: {
+		name: "Pi",
+		commands: ["pi"]
+	},
+	omp: {
+		name: "oh-my-pi",
+		commands: ["omp"],
+		homeDir: ".omp"
+	},
+	copilot: {
+		name: "Copilot CLI",
+		commands: ["copilot"]
+	}
+};
+const runProcess = (file, args) => new Promise((resolve) => {
+	execFile(file, args, {
+		timeout: STEP_TIMEOUT_MS,
+		maxBuffer: 4194304,
+		env: {
+			...process.env,
+			CI: "1",
+			GIT_TERMINAL_PROMPT: "0"
+		},
+		windowsHide: true
+	}, (error, stdout, stderr) => {
+		const output = `${stdout}${stderr}`.trim();
+		resolve(error ? {
+			code: 1,
+			output: output || error.message
+		} : {
+			code: 0,
+			output
+		});
+	});
+});
+async function exists(target) {
+	try {
+		await stat(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findHarness(harness, homeDir, env) {
+	const installed = (harness.installDirs ?? []).map((directory) => path.join(homeDir, directory));
+	for (const command of harness.commands) {
+		const found = await findExecutable(command, env) ?? await findExecutable(command, { PATH: installed.join(path.delimiter) });
+		if (found) return found;
+	}
+}
+async function harnessFound(harness, homeDir, env, platform) {
+	if (await findHarness(harness, homeDir, env)) return true;
+	if (harness.homeDir && await exists(path.join(homeDir, harness.homeDir))) return true;
+	if (platform !== "darwin") return false;
+	for (const app of harness.apps ?? []) if (await exists(app)) return true;
+	return false;
+}
+async function readJson(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+/** Follows `keys` down nested JSON objects. */
+function lookup(value, ...keys) {
+	let current = value;
+	for (const key of keys) {
+		if (!isJsonObject(current)) return void 0;
+		current = current[key];
+	}
+	return current;
+}
+/** Whether a `[plugins."…"]` table names the plugin, and does not turn it
+* off. */
+function codexHasPlugin(toml) {
+	const lines = toml.split("\n");
+	const start = lines.findIndex((line) => line.trim() === `[plugins."${PLUGIN}"]`);
+	if (start === -1) return false;
+	for (const line of lines.slice(start + 1)) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("[")) break;
+		if (/^enabled\s*=\s*false\b/.test(trimmed)) return false;
+	}
+	return true;
+}
+/** Whether a harness already has Whiteboard, as its own config records it:
+* the plugin it installed, or the MCP server added to it. Copilot keeps no
+* record Whiteboard reads, so it always installs again, which is harmless. */
+async function harnessConnected(target, homeDir, env, platform) {
+	const claudeDir = env.CLAUDE_CONFIG_DIR ?? path.join(homeDir, ".claude");
+	const hasServer = async (file, ...keys) => lookup(await readJson(file), ...keys, "whiteboard") !== void 0;
+	switch (target) {
+		case "claude": {
+			if (platform === "win32") return hasServer(path.join(homeDir, ".claude.json"), "mcpServers");
+			const [installed, settings] = await Promise.all([readJson(path.join(claudeDir, "plugins", "installed_plugins.json")), readJson(path.join(claudeDir, "settings.json"))]);
+			const installs = lookup(installed, "plugins", PLUGIN);
+			return Array.isArray(installs) && installs.length > 0 && lookup(settings, "enabledPlugins", PLUGIN) !== false;
+		}
+		case "codex": try {
+			return codexHasPlugin(await readFile(path.join(env.CODEX_HOME ?? path.join(homeDir, ".codex"), "config.toml"), "utf8"));
+		} catch {
+			return false;
+		}
+		case "opencode": {
+			const config = await readJson(path.join(env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config"), "opencode", "opencode.json"));
+			return lookup(config, "mcp", "whiteboard") !== void 0 || lookup(config, "mcp", "servers", "whiteboard") !== void 0;
+		}
+		case "pi": return hasServer(path.join(homeDir, ".pi", "agent", "mcp.json"), "mcpServers");
+		case "omp": return hasServer(path.join(homeDir, ".omp", "agent", "mcp.json"), "mcpServers");
+		case "cursor": return cursorHasServer(homeDir);
+		case "copilot": return false;
+	}
+}
+/** Every harness Whiteboard connects to, whether this machine has it, and
+* whether it already has Whiteboard. */
+async function detectConnectAgents(input = {}) {
+	const homeDir = input.homeDir ?? os.homedir();
+	const env = input.env ?? process.env;
+	const platform = input.platform ?? process.platform;
+	return Promise.all(ALL_INSTALL_TARGETS.map(async (target) => {
+		const found = await harnessFound(HARNESSES[target], homeDir, env, platform);
+		return {
+			target,
+			name: HARNESSES[target].name,
+			found,
+			connected: found && await harnessConnected(target, homeDir, env, platform)
+		};
+	}));
+}
+const ALREADY = /already/i;
+/** The commands that install Whiteboard into a CLI harness, as
+* connect-prompts.ts tells an agent to run them. */
+function cliSteps(target, launch, platform) {
+	const marketplace = {
+		args: [
+			"plugin",
+			"marketplace",
+			"add",
+			MARKETPLACE
+		],
+		optional: true
+	};
+	const windowsServer = (scope) => ({
+		args: [
+			"mcp",
+			"add",
+			...scope,
+			"whiteboard",
+			"--",
+			launch.command,
+			...launch.args
+		],
+		done: ALREADY
+	});
+	switch (target) {
+		case "claude": return platform === "win32" ? [windowsServer(["-s", "user"])] : [marketplace, {
+			args: [
+				"plugin",
+				"install",
+				PLUGIN,
+				"--scope",
+				"user"
+			],
+			done: ALREADY
+		}];
+		case "codex": return [marketplace, {
+			args: [
+				"plugin",
+				"add",
+				PLUGIN
+			],
+			done: ALREADY
+		}];
+		case "copilot": return platform === "win32" ? [windowsServer([])] : [marketplace, {
+			args: [
+				"plugin",
+				"install",
+				PLUGIN
+			],
+			done: ALREADY
+		}];
+		case "opencode": return [{
+			args: [
+				"mcp",
+				"add",
+				"--global",
+				"whiteboard",
+				"--",
+				launch.command,
+				...launch.args
+			],
+			done: ALREADY
+		}];
+		case "pi": return [{
+			args: [
+				"mcp",
+				"add",
+				"whiteboard",
+				"--",
+				launch.command,
+				...launch.args
+			],
+			done: ALREADY
+		}];
+	}
+}
+/** oh-my-pi reads its MCP servers from one JSON file; merge ours in. */
+async function connectOmp(homeDir, launch) {
+	const file = path.join(homeDir, ".omp", "agent", "mcp.json");
+	try {
+		const config = await exists(file) ? JSON.parse(await readFile(file, "utf8")) : {};
+		if (!isJsonObject(config)) throw new Error(`${file} is not a JSON object.`);
+		const servers = isJsonObject(config.mcpServers) ? { ...config.mcpServers } : {};
+		servers.whiteboard = {
+			command: launch.command,
+			args: [...launch.args]
+		};
+		const next = {
+			...config,
+			mcpServers: servers
+		};
+		await mkdir(path.dirname(file), { recursive: true });
+		await writeFile(file, `${JSON.stringify(next, null, 2)}\n`);
+		return {
+			target: "omp",
+			state: "connected",
+			output: `Updated ${file}`
+		};
+	} catch (error) {
+		return {
+			target: "omp",
+			state: "failed",
+			output: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/** Whether Cursor's global MCP config already names Whiteboard's server. */
+async function cursorHasServer(homeDir) {
+	try {
+		const config = JSON.parse(await readFile(path.join(homeDir, ".cursor", "mcp.json"), "utf8"));
+		return isJsonObject(config) && isJsonObject(config.mcpServers) && config.mcpServers.whiteboard !== void 0;
+	} catch {
+		return false;
+	}
+}
+/** Cursor only installs an MCP server the user confirms, so open its link,
+* unless it already has one: confirming again would ask for nothing new. */
+async function connectCursor(homeDir, launch, platform, run) {
+	if (await cursorHasServer(homeDir)) return {
+		target: "cursor",
+		state: "connected",
+		output: "Cursor already has the whiteboard MCP server."
+	};
+	const url = cursorInstallDeeplink(launch);
+	const [file, args] = platform === "darwin" ? ["open", ["-g", url]] : platform === "win32" ? ["cmd", [
+		"/d",
+		"/c",
+		"start",
+		"\"\"",
+		url
+	]] : ["xdg-open", [url]];
+	const result = await run(file, args);
+	return {
+		target: "cursor",
+		state: result.code === 0 ? "approve" : "failed",
+		output: result.output
+	};
+}
+/** Installs Whiteboard's plugin, or its MCP server, into one harness. */
+async function connectAgent(target, input) {
+	const homeDir = input.homeDir ?? os.homedir();
+	const env = input.env ?? process.env;
+	const platform = input.platform ?? process.platform;
+	const run = input.run ?? runProcess;
+	const launch = reviewMcpLaunch(input.hasShim, platform);
+	if (target === "omp") return connectOmp(homeDir, launch);
+	if (target === "cursor") return connectCursor(homeDir, launch, platform, run);
+	const executable = await findHarness(HARNESSES[target], homeDir, env);
+	if (!executable) return {
+		target,
+		state: "failed",
+		output: `${HARNESSES[target].name} is not installed.`
+	};
+	const outputs = [];
+	for (const step of cliSteps(target, launch, platform)) {
+		const result = await run(executable, step.args);
+		outputs.push(result.output);
+		if (result.code !== 0 && !step.optional && !step.done?.test(result.output)) return {
+			target,
+			state: "failed",
+			output: outputs.join("\n").trim()
+		};
+	}
+	return {
+		target,
+		state: "connected",
+		output: outputs.join("\n").trim()
+	};
+}
+//#endregion
 //#region src/review-preferences.ts
 const DEFAULT_REVIEW_PREFERENCES = { scratchpadEnabled: false };
 function reviewPreferencesPath(devHome = devReviewHome()) {
@@ -726,6 +1123,1188 @@ function createJsonReviewReporting(store, telemetry, options = {}) {
 	return app;
 }
 //#endregion
+//#region src/server/legacy-tutorial-cleanup.ts
+/**
+* Earlier versions shipped a three-minute tutorial: a managed review over a
+* sample checkout under ~/.dev/tutorial. Whiteboard no longer has one, so
+* remove what an earlier version left behind. Best effort: a failure leaves
+* it for the next start.
+*/
+async function removeLegacyTutorial(input) {
+	const tutorialRoot = input.root ?? path.join(devReviewHome(), "tutorial");
+	try {
+		for (const reviewId of input.store.legacyTutorialIds()) await input.store.execute({ operation: {
+			type: "delete",
+			reviewId
+		} });
+		for (const repository of input.store.repositories()) {
+			const relative = path.relative(tutorialRoot, repository.path);
+			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) await input.data.forgetRepository(repository.id);
+		}
+		await rm(tutorialRoot, {
+			recursive: true,
+			force: true,
+			maxRetries: 10
+		});
+	} catch (error) {
+		console.warn("[Whiteboard] Removing the old tutorial failed:", error);
+	}
+}
+const MAX_RETRY_MS = 3e4;
+const FIRST_BYTE_TIMEOUT_MS = 1e4;
+const NO_ANSWER = `it did not answer within ${FIRST_BYTE_TIMEOUT_MS / 1e3} seconds`;
+const jitter = (ms) => ms * (.75 + Math.random() * .5);
+const STEADY_MS = 1e4;
+const MAX_LINE_CHARS = 67108864;
+const sleep = (ms, signal) => setTimeout$1(ms, void 0, { signal }).catch(() => void 0);
+async function reconnect(signal, attempt) {
+	let wait = 500;
+	while (!signal.aborted) {
+		const started = Date.now();
+		await attempt();
+		if (signal.aborted) return;
+		if (Date.now() - started >= STEADY_MS) wait = 500;
+		await sleep(jitter(wait), signal);
+		wait = Math.min(wait * 2, MAX_RETRY_MS);
+	}
+}
+async function readLines(body, line) {
+	const decoder = new TextDecoder();
+	let pending = "";
+	for await (const chunk of body) {
+		pending += decoder.decode(chunk, { stream: true });
+		let end;
+		while ((end = pending.indexOf("\n")) !== -1) {
+			line(pending.slice(0, end));
+			pending = pending.slice(end + 1);
+		}
+		if (pending.length > MAX_LINE_CHARS) throw new Error("A line is too long.");
+	}
+}
+function keepOpen(input) {
+	const { remote, signal } = input;
+	reconnect(signal, async () => {
+		let timedOut = false;
+		try {
+			const response = await send(remote, {
+				method: "GET",
+				path: input.path,
+				headers: remoteHeaders(remote),
+				signal
+			});
+			if (response.statusCode === 200) await input.read(response.body);
+			else await response.body.dump();
+		} catch (error) {
+			timedOut = errorCode(error) === "UND_ERR_HEADERS_TIMEOUT";
+		}
+		if (signal.aborted) return;
+		if (timedOut) input.hosts.failed(remote, NO_ANSWER);
+		else input.hosts.recheck(remote);
+	});
+}
+const remoteHeaders = (remote) => ({
+	"x-review-token": remote.endpoint?.token ?? "",
+	[REVIEW_CLIENT_HEADER]: REVIEW_CLIENT_REMOTE
+});
+async function send(remote, input, retry = true) {
+	if (!remote.endpoint) throw new Error(`${remote.alias} has no endpoint.`);
+	let response;
+	try {
+		response = await request(new URL(input.path, remote.endpoint.url), {
+			dispatcher: remote.dispatcher,
+			method: input.method,
+			headers: input.headers,
+			body: input.body,
+			signal: input.signal,
+			headersTimeout: input.headersTimeout ?? 1e4,
+			bodyTimeout: 0
+		});
+	} catch (error) {
+		if (retry && !input.signal?.aborted && !(input.body instanceof Readable) && errorCode(error) === "UND_ERR_SOCKET" && (input.body === void 0 || reusedSocket(error))) return send(remote, input, false);
+		throw error;
+	}
+	if (response.statusCode === 401) remote.unauthorized?.();
+	return response;
+}
+async function readBody(body, limit) {
+	const parts = [];
+	let size = 0;
+	for await (const part of body) {
+		const chunk = part;
+		size += chunk.byteLength;
+		if (size > limit) {
+			body.destroy();
+			throw new StreamLimitError();
+		}
+		parts.push(chunk);
+	}
+	return Buffer.concat(parts, size);
+}
+const codedError = z.object({ code: z.string() });
+const socketError = z.object({ socket: z.object({ bytesRead: z.number() }) });
+const reusedSocket = (cause) => (socketError.safeParse(cause).data?.socket.bytesRead ?? 0) > 0;
+const ERROR_WORDS = /* @__PURE__ */ new Map([
+	["ECONNREFUSED", "it refused the connection"],
+	["ECONNRESET", "it closed the connection"],
+	["UND_ERR_SOCKET", "it closed the connection"],
+	["EPIPE", "it closed the connection"],
+	["ETIMEDOUT", "it did not answer"],
+	["UND_ERR_HEADERS_TIMEOUT", NO_ANSWER]
+]);
+function errorCode(cause) {
+	if (!(cause instanceof Error)) return String(cause);
+	return codedError.safeParse(cause).data?.code ?? codedError.safeParse(cause.cause).data?.code ?? cause.message;
+}
+function errorText(cause) {
+	const code = errorCode(cause);
+	return ERROR_WORDS.get(code) ?? `it failed (${code})`;
+}
+//#endregion
+//#region src/server/review-gateway-hosts.ts
+const HEALTH_TIMEOUT_MS = 3e3;
+const HEARTBEAT_MS = 1e4;
+const INSTALLS = /* @__PURE__ */ new Set(["incompatible", "not-installed"]);
+const INSTALL_STEPS = {
+	preparing: "Preparing to install Whiteboard",
+	"waiting-for-lock": "Waiting for another install to finish",
+	package: "Installing the Whiteboard package",
+	done: "Installed; starting the server"
+};
+const healthSchema = z.object({
+	ok: z.literal(true),
+	serverId: z.string().optional(),
+	version: z.string()
+});
+function createGatewayHosts(input) {
+	const log = input.log ?? (() => {});
+	let hosts = [];
+	let closed = false;
+	const reported = /* @__PURE__ */ new Map();
+	const sharing = (host) => host.serverId === void 0 ? [host] : hosts.filter((other) => other.serverId === host.serverId);
+	const serving = (serverId) => serverId === void 0 ? void 0 : hosts.find((host) => host.status === "online" && host.serverId === serverId && sharing(host).length === 1);
+	function stateOf(host) {
+		const known = {
+			alias: host.alias,
+			...host.serverId !== void 0 && { serverId: host.serverId }
+		};
+		const aliases = sharing(host).map((other) => other.alias);
+		if (aliases.length > 1) return {
+			...known,
+			state: "duplicate",
+			detail: `${aliases.join(", ")} report the same server id, so Whiteboard uses none of them. If they are one machine, keep one alias. If they are separate machines, run \`whiteboard server stop\` and then \`whiteboard server reset-id\` on all but one.`
+		};
+		const detail = host.status === "incompatible" && host.installFailure ? `${host.detail ? `${host.detail} ` : ""}${host.installFailure}` : host.detail;
+		return {
+			...known,
+			state: host.status,
+			...detail !== void 0 && { detail },
+			...INSTALLS.has(host.status) && host.problem?.state !== "incompatible" && { installCommand: [`mkdir -p ~/.dev/whiteboard-remote && rm -rf ~/.dev/whiteboard-remote/whiteboard-remote && curl -fsSL https://install.dev.fast/releases/${input.version}/remote/whiteboard-remote-${input.version}-${host.target ?? "linux-x64"}.tar.xz | tar -xJ -C ~/.dev/whiteboard-remote`, "mkdir -p ~/.local/bin && ln -sf ~/.dev/whiteboard-remote/whiteboard-remote/whiteboard ~/.local/bin/whiteboard"].join("\n") },
+			...host.declined && host.status !== "online" && host.status !== "connecting" && { declined: true },
+			...host.status === "online" && languageOf(host)
+		};
+	}
+	function report() {
+		const states = hosts.map(stateOf);
+		for (const host of hosts) if (host.serverId !== void 0 && serving(host.serverId) === host) input.machine?.(host.serverId, host.alias);
+		for (const state of states) {
+			const line = `${state.state}${state.detail ? ` (${state.detail})` : ""}`;
+			if (reported.get(state.alias) === line) continue;
+			reported.set(state.alias, line);
+			log(`Host ${state.alias}: ${line}`);
+		}
+		for (const alias of reported.keys()) if (!states.some((state) => state.alias === alias)) reported.delete(alias);
+		input.changed?.();
+	}
+	function restartedHost(host, detail = `${host.alias} restarted; attaching again.`) {
+		if (closed || !host.endpoint) return;
+		host.endpoint = void 0;
+		clearTimeout(host.retry);
+		host.checking?.abort();
+		host.checking = void 0;
+		host.status = "offline";
+		host.detail = detail;
+		report();
+		input.restarted?.(host.alias);
+	}
+	function dispose(host) {
+		clearTimeout(host.retry);
+		host.checking?.abort();
+		host.checking = void 0;
+		host.dispatcher?.destroy();
+	}
+	function create(given) {
+		const host = {
+			alias: given.alias,
+			status: "connecting",
+			retryMs: 500,
+			...languageOf(given),
+			...given.target && { target: given.target }
+		};
+		if (given.endpoint) host.endpoint = given.endpoint;
+		if (given.declined) host.declined = true;
+		if (given.installFailure) host.installFailure = given.installFailure;
+		if (given.problem) {
+			host.problem = given.problem;
+			host.status = given.problem.state;
+			host.detail = given.problem.detail;
+		} else if (given.installing && !given.endpoint) {
+			host.installing = given.installing;
+			host.status = "installing";
+			host.detail = `${INSTALL_STEPS[given.installing.step]}.`;
+		} else if (given.asking && !given.endpoint) {
+			host.asking = given.asking;
+			host.detail = `Waiting for an answer: install Whiteboard ${given.asking} on ${given.alias}?`;
+		} else if (!given.endpoint) host.detail = `Waiting for a connection to ${given.alias}.`;
+		else {
+			host.dispatcher = new Agent();
+			host.unauthorized = () => restartedHost(host);
+		}
+		return host;
+	}
+	function schedule(host, ms) {
+		host.retry = setTimeout(() => void check(host), ms);
+		host.retry.unref();
+	}
+	function retryLater(host) {
+		schedule(host, jitter(host.retryMs));
+		host.retryMs = Math.min(host.retryMs * 2, MAX_RETRY_MS);
+	}
+	async function check(host) {
+		if (closed || !host.endpoint || host.problem) return;
+		clearTimeout(host.retry);
+		host.checking?.abort();
+		const abort = new AbortController();
+		host.checking = abort;
+		const timeout = AbortSignal.timeout(HEALTH_TIMEOUT_MS);
+		let health;
+		let reason = "it did not answer";
+		try {
+			const response = await send(host, {
+				method: "GET",
+				path: "/health",
+				headers: { "x-review-token": host.endpoint.token },
+				signal: AbortSignal.any([abort.signal, timeout])
+			});
+			const parsed = healthSchema.safeParse(JSON.parse((await readBody(response.body, 65536)).toString()));
+			if (parsed.success) health = parsed.data;
+			else reason = "it did not answer as a Whiteboard server";
+		} catch (error) {
+			if (timeout.aborted) reason = `it did not answer within ${HEALTH_TIMEOUT_MS / 1e3} seconds`;
+			else if (!abort.signal.aborted) reason = errorText(error);
+		}
+		if (host.checking !== abort) return;
+		host.checking = void 0;
+		if (health && health.serverId === void 0) return restartedHost(host);
+		if (!health && host.serverId !== void 0) return restartedHost(host, `${host.alias} is offline: ${reason}; attaching again.`);
+		if (!health) {
+			host.status = "offline";
+			host.detail = `${host.alias} is offline: ${reason}.`;
+			retryLater(host);
+		} else {
+			host.serverId = health.serverId;
+			host.retryMs = 500;
+			if (health.version === "unknown" || health.version !== input.version) {
+				host.status = "incompatible";
+				host.detail = `${host.alias} runs Whiteboard ${health.version}; this Desktop runs ${input.version}. Install Whiteboard ${input.version} on ${host.alias}.`;
+			} else {
+				host.status = "online";
+				host.detail = void 0;
+			}
+			schedule(host, input.heartbeatMs ?? HEARTBEAT_MS);
+		}
+		report();
+	}
+	return {
+		set(list) {
+			const previous = new Map(hosts.map((host) => [host.alias, host]));
+			const next = [];
+			const changed = [];
+			for (const given of list) {
+				if (next.some((host) => host.alias === given.alias)) continue;
+				const current = previous.get(given.alias);
+				if (current && JSON.stringify([
+					current.endpoint,
+					current.problem,
+					current.installing,
+					current.declined,
+					current.asking,
+					current.installFailure
+				]) === JSON.stringify([
+					given.endpoint,
+					given.problem,
+					given.installing,
+					given.declined,
+					given.asking,
+					given.installFailure
+				])) {
+					previous.delete(given.alias);
+					current.languageFeatures = given.languageFeatures;
+					current.languageFeaturesDetail = given.languageFeaturesDetail;
+					current.languageGroups = given.languageGroups;
+					current.target = given.target;
+					next.push(current);
+				} else {
+					const host = create(given);
+					next.push(host);
+					changed.push(host);
+				}
+			}
+			for (const gone of previous.values()) dispose(gone);
+			hosts = next;
+			for (const host of changed) check(host);
+			report();
+		},
+		states: () => hosts.map(stateOf),
+		serving: (serverId) => serving(serverId),
+		online: () => hosts.filter((host) => serving(host.serverId) === host),
+		failed(remote, reason) {
+			const host = hosts.find((candidate) => candidate === remote);
+			if (!host || host.status !== "online") return;
+			host.status = "offline";
+			host.detail = `${host.alias} is offline: ${reason}.`;
+			report();
+			check(host);
+		},
+		recheck(remote) {
+			const host = hosts.find((candidate) => candidate === remote);
+			if (host && !host.checking) check(host);
+		},
+		close() {
+			closed = true;
+			for (const host of hosts) dispose(host);
+		}
+	};
+}
+const languageOf = ({ languageFeatures, languageFeaturesDetail, languageGroups }) => ({
+	...languageFeatures !== void 0 && { languageFeatures },
+	...languageFeaturesDetail !== void 0 && { languageFeaturesDetail },
+	...languageGroups !== void 0 && { languageGroups }
+});
+//#endregion
+//#region src/server/review-gateway-memory.ts
+const LIST_MODES = ["structural", "textual"];
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const listEntrySchema = z.looseObject({
+	reviewId: z.string().regex(UUID),
+	version: z.number(),
+	title: z.string(),
+	createdAt: z.string(),
+	repositoryName: z.string(),
+	viewedAt: z.string().nullable(),
+	trashedAt: z.string().nullable(),
+	repositoryGroup: z.object({
+		key: z.string(),
+		label: z.string()
+	}).optional()
+});
+const listEntriesSchema = z.array(z.unknown()).transform((entries) => entries.filter((entry) => listEntrySchema.safeParse(entry).success));
+const lastListSchema = z.object({
+	structural: listEntriesSchema.optional(),
+	textual: listEntriesSchema.optional()
+});
+const memorySchema = z.record(z.string(), z.object({
+	alias: z.string(),
+	lastList: lastListSchema.optional()
+}));
+function gatewayMemoryPath(home) {
+	return path.join(home, "remotes.json");
+}
+function openGatewayMemory(home, log = () => {}) {
+	const file = gatewayMemoryPath(home);
+	const servers = /* @__PURE__ */ new Map();
+	try {
+		const saved = memorySchema.parse(JSON.parse(readFileSync(file, "utf8")));
+		for (const [serverId, { alias, lastList }] of Object.entries(saved)) servers.set(serverId, {
+			alias,
+			lastList: lastList ?? {}
+		});
+	} catch (error) {
+		if (error.code !== "ENOENT") log(`Ignoring unreadable remote review memory ${file}: ${String(error)}`);
+	}
+	let writing = Promise.resolve();
+	let queued = false;
+	const save = () => {
+		if (queued) return;
+		queued = true;
+		writing = writing.then(() => {
+			queued = false;
+			return writePrivateJsonAtomic(file, Object.fromEntries(servers));
+		}).catch((cause) => log(`Could not save remote review memory: ${errorMessage(cause)}`));
+	};
+	return {
+		serverIdOf(alias) {
+			for (const [serverId, server] of servers) if (server.alias === alias) return serverId;
+		},
+		list: (serverId, mode) => servers.get(serverId)?.lastList[mode],
+		setList(serverId, alias, mode, reviews) {
+			let server = servers.get(serverId);
+			if (!server) {
+				server = {
+					alias,
+					lastList: {}
+				};
+				servers.set(serverId, server);
+			} else if (server.alias === alias && JSON.stringify(server.lastList[mode]) === JSON.stringify(reviews)) return;
+			server.alias = alias;
+			server.lastList[mode] = reviews;
+			save();
+		},
+		rename(serverId, alias) {
+			const server = servers.get(serverId);
+			if (!server || server.alias === alias) return;
+			server.alias = alias;
+			save();
+		},
+		flush: () => writing
+	};
+}
+//#endregion
+//#region src/server/review-gateway-list.ts
+function decorate(entry, state, hostState) {
+	const { alias } = state;
+	const online = hostState === "online";
+	const features = online && state.languageFeatures === true;
+	const reason = online ? features ? void 0 : state.languageFeaturesDetail : reviewHostStatus({
+		alias,
+		state: hostState,
+		detail: hostState === state.state ? state.detail : void 0
+	}).sentence;
+	return {
+		...entry,
+		...entry.repositoryGroup && { repositoryGroup: {
+			key: `${alias}:${entry.repositoryGroup.key}`,
+			label: entry.repositoryGroup.label
+		} },
+		host: alias,
+		hostState,
+		available: {
+			sourceWindows: features,
+			...reason && { reason }
+		}
+	};
+}
+const hostStateOf = (state, serving) => {
+	if (serving) return "online";
+	return state.state === "online" || state.state === "duplicate" ? "offline" : state.state;
+};
+function* servers(source) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const state of source.states) {
+		const serverId = state.serverId ?? source.serverIdOf(state.alias);
+		if (serverId === void 0 || seen.has(serverId)) continue;
+		seen.add(serverId);
+		yield {
+			state,
+			serverId
+		};
+	}
+}
+function listedBy(reviewId, source) {
+	for (const server of servers(source)) if (LIST_MODES.some((mode) => source.list(server.serverId, mode)?.some((entry) => entry.reviewId === reviewId))) return server;
+}
+function mergeLists(mode, local, source) {
+	const ids = new Set(local.map((entry) => entry.reviewId));
+	const merged = [...local];
+	for (const { state, serverId } of servers(source)) {
+		const hostState = hostStateOf(state, source.serving(serverId));
+		for (const entry of source.list(serverId, mode) ?? []) if (!ids.has(entry.reviewId)) {
+			ids.add(entry.reviewId);
+			merged.push(decorate(entry, state, hostState));
+		}
+	}
+	return merged;
+}
+//#endregion
+//#region src/server/review-gateway-pushes.ts
+const REMOTE_VERBS = /* @__PURE__ */ new Set([
+	"authoringCapabilities",
+	"openApiReview",
+	"focusWindow"
+]);
+function createGatewayPushes(input) {
+	const { hosts, relay } = input;
+	const links = /* @__PURE__ */ new Map();
+	async function answer(remote, request) {
+		if (!REMOTE_VERBS.has(request.name)) return {
+			ok: false,
+			error: `${request.name} is not available from another machine.`
+		};
+		if (request.name === "openApiReview") {
+			const { reviewId } = request.args;
+			if (!UUID.test(reviewId)) return {
+				ok: false,
+				error: `${reviewId} cannot be opened from ${remote.alias}: a review on another machine has a UUID.`
+			};
+			const refused = await input.claim(remote, reviewId);
+			if (refused) return {
+				ok: false,
+				error: refused
+			};
+		}
+		return relay.dispatch(request);
+	}
+	async function reply(remote, id, response) {
+		try {
+			await (await send(remote, {
+				method: "POST",
+				path: "/control/result",
+				headers: {
+					...remoteHeaders(remote),
+					"content-type": "application/json"
+				},
+				body: Buffer.from(JSON.stringify({
+					id,
+					response
+				})),
+				signal: AbortSignal.timeout(FIRST_BYTE_TIMEOUT_MS)
+			})).body.dump();
+		} catch (error) {
+			input.log(`Could not answer ${remote.alias}'s push: ${errorText(error)}.`);
+		}
+	}
+	async function push(remote, data) {
+		let frame;
+		try {
+			frame = parseReviewDesktopVerbFrame(parseJsonText(data));
+		} catch {
+			input.log(`Ignored an unreadable push from ${remote.alias}.`);
+			return;
+		}
+		let response;
+		try {
+			response = await answer(remote, frame.request);
+		} catch (error) {
+			response = {
+				ok: false,
+				error: errorText(error)
+			};
+		}
+		await reply(remote, frame.id, response);
+	}
+	return {
+		changed() {
+			const online = new Set(relay.attached ? hosts.online() : []);
+			for (const [remote, abort] of links) if (!online.has(remote)) {
+				abort.abort();
+				links.delete(remote);
+			}
+			for (const remote of online) {
+				if (links.has(remote)) continue;
+				const abort = new AbortController();
+				links.set(remote, abort);
+				keepOpen({
+					hosts,
+					remote,
+					path: "/control",
+					signal: abort.signal,
+					read: (body) => readLines(body, (line) => {
+						if (line.startsWith("data: ")) push(remote, line.slice(6));
+					})
+				});
+			}
+		},
+		close() {
+			for (const abort of links.values()) abort.abort();
+			links.clear();
+		}
+	};
+}
+//#endregion
+//#region src/server/review-gateway-streams.ts
+const subscriptionsSchema = z.array(z.strictObject({
+	reviewId: z.string().min(1).nullable(),
+	mode: coverageModeSchema
+}));
+const lineSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("list"),
+	mode: z.enum(LIST_MODES),
+	reviews: z.array(z.unknown())
+}), z.object({
+	kind: z.literal("review"),
+	reviewId: z.string(),
+	value: z.unknown().optional()
+})]);
+const downDetail = (down) => reviewHostStatus(down).sentence;
+const watchPath = (subscriptions) => `/reviews-api/watch?subscriptions=${encodeURIComponent(JSON.stringify(subscriptions))}`;
+function parseLine(text) {
+	try {
+		return lineSchema.safeParse(parseJsonText(text)).data;
+	} catch {
+		return;
+	}
+}
+function createGatewayStreams(input) {
+	const { hosts, memory } = input;
+	const feeds = /* @__PURE__ */ new Map();
+	const clients = /* @__PURE__ */ new Set();
+	const passThrough = /* @__PURE__ */ new Set();
+	const merge = (mode, local) => mergeLists(mode, local, input.lists());
+	function feedLine(remote, text) {
+		const line = parseLine(text);
+		if (line?.kind !== "list" || remote.serverId === void 0) return;
+		memory.setList(remote.serverId, remote.alias, line.mode, listEntriesSchema.parse(line.reviews));
+		input.listed();
+		for (const client of clients) client.refresh();
+	}
+	function syncFeeds() {
+		const online = new Set(hosts.online());
+		for (const [remote, abort] of feeds) if (!online.has(remote)) {
+			abort.abort();
+			feeds.delete(remote);
+		}
+		for (const remote of online) {
+			if (feeds.has(remote)) continue;
+			const abort = new AbortController();
+			feeds.set(remote, abort);
+			keepOpen({
+				hosts,
+				remote,
+				path: watchPath(LIST_MODES.map((mode) => ({
+					reviewId: null,
+					mode
+				}))),
+				signal: abort.signal,
+				read: (body) => readLines(body, (text) => feedLine(remote, text))
+			});
+		}
+	}
+	function openClient(subscriptions, signal) {
+		const modes = /* @__PURE__ */ new Set();
+		const reviews = /* @__PURE__ */ new Map();
+		for (const { reviewId, mode } of subscriptions) if (reviewId === null) modes.add(mode);
+		else if (!reviews.has(reviewId)) reviews.set(reviewId, mode);
+		const encoder = new TextEncoder();
+		const pending = /* @__PURE__ */ new Map();
+		const sent = /* @__PURE__ */ new Map();
+		const localLists = /* @__PURE__ */ new Map();
+		const reportedDown = /* @__PURE__ */ new Set();
+		const upstreams = /* @__PURE__ */ new Map();
+		let controller;
+		let flushing = false;
+		let stopped = false;
+		const flush = () => {
+			if (!controller || !pending.size) return;
+			if (controller.desiredSize === null || controller.desiredSize <= 0) return;
+			const lines = [];
+			for (const [item, line] of pending) if (sent.get(item) !== line) {
+				lines.push(line);
+				sent.set(item, line);
+			}
+			pending.clear();
+			if (lines.length) controller.enqueue(encoder.encode(`${lines.join("\n")}\n`));
+		};
+		const emit = (item, line) => {
+			if (stopped) return;
+			pending.set(item, line);
+			if (flushing) return;
+			flushing = true;
+			queueMicrotask(() => {
+				flushing = false;
+				flush();
+			});
+		};
+		const emitList = (mode) => {
+			const local = localLists.get(mode);
+			if (local) emit(`list:${mode}`, JSON.stringify({
+				kind: "list",
+				mode,
+				reviews: merge(mode, local)
+			}));
+		};
+		const emitReview = (reviewId, text) => {
+			reportedDown.delete(reviewId);
+			emit(`review:${reviewId}`, text);
+		};
+		const down = (reviewId, state) => {
+			if (reportedDown.has(reviewId)) return;
+			reportedDown.add(reviewId);
+			emit(`review:${reviewId}`, JSON.stringify({
+				kind: "review",
+				reviewId,
+				error: downDetail(state)
+			}));
+		};
+		const openLocal = (ids, abort) => {
+			const path = watchPath([...[...modes].map((mode) => ({
+				reviewId: null,
+				mode
+			})), ...[...ids].map(([reviewId, mode]) => ({
+				reviewId,
+				mode
+			}))]);
+			reconnect(abort, async () => {
+				try {
+					const response = await input.local(new Request(`http://gateway${path}`));
+					if (response.body) await readLines(Readable.fromWeb(response.body, { signal: abort }), (text) => {
+						const line = parseLine(text);
+						if (line?.kind === "list" && modes.has(line.mode)) {
+							localLists.set(line.mode, line.reviews);
+							emitList(line.mode);
+						} else if (line?.kind === "review" && ids.has(line.reviewId)) emitReview(line.reviewId, text);
+					});
+				} catch {}
+			});
+		};
+		const openRemote = (remote, ids, abort) => keepOpen({
+			hosts,
+			remote,
+			path: watchPath([...ids].map(([reviewId, mode]) => ({
+				reviewId,
+				mode
+			}))),
+			signal: abort,
+			read: (body) => readLines(body, (text) => {
+				const line = parseLine(text);
+				if (line?.kind === "review" && ids.has(line.reviewId)) emitReview(line.reviewId, text);
+			})
+		});
+		const client = {
+			refresh() {
+				if (stopped) return;
+				for (const mode of modes) emitList(mode);
+				const wanted = /* @__PURE__ */ new Map();
+				const want = (key, reviewId) => {
+					let ids = wanted.get(key);
+					if (!ids) wanted.set(key, ids = /* @__PURE__ */ new Map());
+					ids.set(reviewId, reviews.get(reviewId));
+				};
+				if (modes.size) wanted.set("local", /* @__PURE__ */ new Map());
+				for (const reviewId of reviews.keys()) {
+					const located = input.locate(reviewId);
+					if (located === void 0 || located === "local") want("local", reviewId);
+					else if ("remote" in located) want(located.remote, reviewId);
+					else if (located.down.state !== "connecting") down(reviewId, located.down);
+				}
+				for (const [key, upstream] of upstreams) {
+					const ids = wanted.get(key);
+					if (ids && JSON.stringify([...ids]) === upstream.key) continue;
+					upstream.abort.abort();
+					upstreams.delete(key);
+				}
+				for (const [key, ids] of wanted) {
+					if (upstreams.has(key)) continue;
+					const abort = new AbortController();
+					upstreams.set(key, {
+						key: JSON.stringify([...ids]),
+						abort
+					});
+					if (key === "local") openLocal(ids, abort.signal);
+					else openRemote(key, ids, abort.signal);
+				}
+			},
+			stop() {
+				if (stopped) return;
+				stopped = true;
+				clients.delete(client);
+				for (const upstream of upstreams.values()) upstream.abort.abort();
+				upstreams.clear();
+				try {
+					controller?.close();
+				} catch {}
+			}
+		};
+		signal.addEventListener("abort", () => client.stop(), { once: true });
+		const body = new ReadableStream({
+			start(started) {
+				controller = started;
+				clients.add(client);
+				client.refresh();
+			},
+			pull: flush,
+			cancel: () => client.stop()
+		});
+		return new Response(body, { headers: {
+			"content-type": "application/x-ndjson",
+			"cache-control": "no-store"
+		} });
+	}
+	async function passLocal(request) {
+		const response = await input.local(request);
+		if (!response.body) return response;
+		let stop = () => {};
+		const { readable, writable } = new TransformStream({ start(controller) {
+			stop = () => controller.terminate();
+		} });
+		passThrough.add(stop);
+		response.body.pipeTo(writable).catch(() => void 0).finally(() => passThrough.delete(stop));
+		return new Response(readable, response);
+	}
+	return {
+		watch(request) {
+			if (!hosts.states().length) return passLocal(request);
+			let subscriptions;
+			try {
+				subscriptions = subscriptionsSchema.parse(JSON.parse(new URL(request.url).searchParams.get("subscriptions") ?? ""));
+			} catch {
+				return input.local(request);
+			}
+			return openClient(subscriptions, request.signal);
+		},
+		async list(request) {
+			const response = await input.local(request);
+			if (!response.ok || !hosts.states().length) return response;
+			const mode = coverageModeSchema.safeParse(new URL(request.url).searchParams.get("mode") ?? void 0).data ?? "structural";
+			const local = await response.json();
+			return serverJson(200, merge(mode, local));
+		},
+		changed() {
+			syncFeeds();
+			if (hosts.states().length) {
+				for (const stop of passThrough) stop();
+				passThrough.clear();
+			}
+			for (const client of clients) client.refresh();
+		},
+		close() {
+			for (const abort of feeds.values()) abort.abort();
+			feeds.clear();
+			for (const stop of passThrough) stop();
+			for (const client of clients) client.stop();
+		}
+	};
+}
+//#endregion
+//#region src/server/review-gateway.ts
+const LOCAL_ROUTES = /* @__PURE__ */ new Set([
+	"repositories",
+	"resources",
+	"workspace-cleanup",
+	"authoring",
+	"capabilities",
+	"status",
+	"instructions",
+	"sharing",
+	"commands"
+]);
+const REMOTE_ROUTES = [
+	{
+		method: "GET",
+		path: ""
+	},
+	{
+		method: "GET",
+		path: "progress"
+	},
+	{
+		method: "POST",
+		path: "progress"
+	},
+	{
+		method: "GET",
+		path: "commits"
+	},
+	{
+		method: "GET",
+		path: "diff"
+	},
+	{
+		method: "GET",
+		path: "structural-diff"
+	},
+	{
+		method: "GET",
+		path: "stack"
+	},
+	{
+		method: "GET",
+		path: "tree"
+	},
+	{
+		method: "GET",
+		path: "file"
+	},
+	{
+		method: "GET",
+		path: "resources/:name"
+	},
+	{
+		method: "GET",
+		path: "maps/:name"
+	},
+	{
+		method: "POST",
+		path: "navigator"
+	},
+	{
+		method: "POST",
+		path: "copy-context"
+	},
+	{
+		method: "GET",
+		path: "language-context",
+		slow: true
+	},
+	{
+		method: "GET",
+		path: "ask/agents"
+	},
+	{
+		method: "GET",
+		path: "ask/agents/:agent/offer",
+		slow: true
+	},
+	{
+		method: "GET",
+		path: "ask/mentions",
+		slow: true
+	},
+	{
+		method: "GET",
+		path: "ask/threads"
+	},
+	{
+		method: "POST",
+		path: "ask/watch"
+	},
+	{
+		method: "GET",
+		path: "ask/:thread"
+	},
+	{
+		method: "POST",
+		path: "ask",
+		slow: true
+	},
+	{
+		method: "POST",
+		path: "ask/:thread/:action{open|choice|permissions}",
+		slow: true
+	},
+	{
+		method: "POST",
+		path: "ask/:thread/:action{prompt|permission|files|retry|cancel|close}"
+	},
+	{
+		method: "DELETE",
+		path: "ask/:thread"
+	}
+];
+const SLOW_ROUTE_TIMEOUT_MS = 12e4;
+const LIST_WAIT_MS = 2e3;
+const HOP_HEADERS = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"transfer-encoding",
+	"content-length",
+	"te",
+	"trailer",
+	"upgrade"
+]);
+const DROPPED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+	...HOP_HEADERS,
+	"host",
+	"origin",
+	"accept-encoding",
+	"cookie",
+	"authorization",
+	"x-review-token",
+	REVIEW_CLIENT_HEADER,
+	REVIEW_HOST_HEADER
+]);
+const commandTarget = z.object({ operation: z.object({ reviewId: z.string().optional() }).optional() });
+function createReviewGateway(input) {
+	const log = input.log ?? (() => {});
+	const memory = openGatewayMemory(input.home, log);
+	let changing = false;
+	let closed = false;
+	const hosts = createGatewayHosts({
+		version: input.version,
+		log,
+		machine: (serverId, alias) => memory.rename(serverId, alias),
+		...input.heartbeatMs !== void 0 && { heartbeatMs: input.heartbeatMs },
+		restarted: (alias) => input.restarted?.(alias),
+		changed() {
+			if (changing) return;
+			changing = true;
+			queueMicrotask(() => {
+				changing = false;
+				if (closed) return;
+				const online = new Set(hosts.online());
+				for (const [abort, remote] of streaming) if (!online.has(remote)) abort.abort();
+				streams.changed();
+				pushes.changed();
+			});
+		}
+	});
+	const streaming = /* @__PURE__ */ new Map();
+	const waiting = /* @__PURE__ */ new Set();
+	const lists = () => ({
+		states: hosts.states(),
+		serving: (serverId) => hosts.serving(serverId) !== void 0,
+		serverIdOf: memory.serverIdOf,
+		list: memory.list
+	});
+	function locate(reviewId) {
+		if (!UUID.test(reviewId) || input.isLocal(reviewId)) return "local";
+		const listed = listedBy(reviewId, lists());
+		if (!listed) return void 0;
+		const remote = hosts.serving(listed.serverId);
+		return remote ? { remote } : { down: listed.state };
+	}
+	function ownerOf(reviewId) {
+		const located = locate(reviewId);
+		if (located !== void 0 || !hosts.online().length) return located;
+		const found = Promise.withResolvers();
+		const settle = (owner) => {
+			clearTimeout(timer);
+			waiting.delete(check);
+			found.resolve(owner);
+		};
+		const check = () => {
+			const owner = locate(reviewId);
+			if (owner !== void 0) settle(owner);
+		};
+		const timer = setTimeout(() => settle(void 0), LIST_WAIT_MS);
+		waiting.add(check);
+		return found.promise;
+	}
+	function answer(alias, status, body) {
+		const response = serverJson(status, body);
+		response.headers.set(REVIEW_HOST_HEADER, alias);
+		return response;
+	}
+	function unavailable(down) {
+		return answer(down.alias, 503, {
+			ok: false,
+			error: downDetail(down)
+		});
+	}
+	async function forward(remote, request, options) {
+		const url = new URL(request.url);
+		const { route } = options;
+		if (url.searchParams.has("token")) url.searchParams.delete("token");
+		const headers = remoteHeaders(remote);
+		request.headers.forEach((value, key) => {
+			if (!DROPPED_REQUEST_HEADERS.has(key)) headers[key] = value;
+		});
+		const limit = route?.slow ? input.slowRouteMs ?? SLOW_ROUTE_TIMEOUT_MS : FIRST_BYTE_TIMEOUT_MS;
+		const abort = new AbortController();
+		const stream = request.body;
+		let response;
+		try {
+			response = await send(remote, {
+				method: request.method,
+				path: `${url.pathname}${url.search}`,
+				headers,
+				body: options.body ?? (stream ? Readable.fromWeb(stream) : void 0),
+				signal: AbortSignal.any([request.signal, abort.signal]),
+				headersTimeout: limit
+			});
+		} catch (error) {
+			const timedOut = errorCode(error) === "UND_ERR_HEADERS_TIMEOUT";
+			const reason = timedOut ? `it did not answer within ${limit / 1e3} seconds` : errorText(error);
+			if (!route?.slow && !request.signal.aborted) hosts.failed(remote, reason);
+			return answer(remote.alias, timedOut ? 504 : 502, {
+				ok: false,
+				error: `Could not reach ${remote.alias}: ${reason}.`
+			});
+		}
+		const { statusCode: status } = response;
+		const out = new Headers();
+		for (const [key, value] of Object.entries(response.headers)) if (value !== void 0 && !HOP_HEADERS.has(key) && !key.startsWith("access-control-")) out.set(key, Array.isArray(value) ? value.join(", ") : value);
+		out.set(REVIEW_HOST_HEADER, remote.alias);
+		if (request.method === "HEAD" || status === 204 || status === 304) {
+			await response.body.dump();
+			return new Response(null, {
+				status,
+				headers: out
+			});
+		}
+		streaming.set(abort, remote);
+		response.body.on("close", () => streaming.delete(abort));
+		const piped = Readable.toWeb(response.body);
+		return new Response(piped, {
+			status,
+			headers: out
+		});
+	}
+	async function command(request) {
+		if (!request.body) return input.local(request);
+		let body;
+		try {
+			body = await readBoundedStream(request.body, DEFAULT_MAX_REQUEST_BYTES);
+		} catch (error) {
+			if (!(error instanceof StreamLimitError)) throw error;
+			return serverJson(413, {
+				ok: false,
+				error: "Request body exceeds 1 MiB."
+			});
+		}
+		let reviewId;
+		try {
+			reviewId = commandTarget.safeParse(parseJsonText(body.toString())).data?.operation?.reviewId;
+		} catch {}
+		const owner = reviewId === void 0 ? void 0 : await ownerOf(reviewId);
+		if (owner === void 0 || owner === "local") return input.local(new Request(request.url, {
+			method: request.method,
+			headers: request.headers,
+			body: new Uint8Array(body),
+			signal: request.signal
+		}));
+		if ("down" in owner) return unavailable(owner.down);
+		return forward(owner.remote, request, { body });
+	}
+	async function review(request, reviewId, route) {
+		if (!reviewId || LOCAL_ROUTES.has(reviewId)) return input.local(request);
+		const owner = await ownerOf(reviewId);
+		if (owner === void 0 || owner === "local") return input.local(request);
+		const alias = "remote" in owner ? owner.remote.alias : owner.down.alias;
+		if (route === "telemetry") {
+			await request.body?.cancel();
+			return answer(alias, 200, { ok: true });
+		}
+		if (!route) return answer(alias, 404, {
+			ok: false,
+			error: "This route is not available for a review on another machine."
+		});
+		if ("down" in owner) return unavailable(owner.down);
+		return forward(owner.remote, request, { route });
+	}
+	const app = new Hono({ strict: false }).basePath("/reviews-api");
+	app.post("/commands", (context) => command(context.req.raw));
+	app.get("/", (context) => streams.list(context.req.raw));
+	app.get("/watch", (context) => streams.watch(context.req.raw));
+	app.all("/:id/telemetry/*", (context) => review(context.req.raw, context.req.param("id"), "telemetry"));
+	for (const route of REMOTE_ROUTES) app.on(route.method, `/:id${route.path && `/${route.path}`}`, (context) => review(context.req.raw, context.req.param("id") ?? "", route));
+	for (const path of ["/:id", "/:id/*"]) app.all(path, (context) => review(context.req.raw, context.req.param("id") ?? ""));
+	app.all("*", (context) => input.local(context.req.raw));
+	const streams = createGatewayStreams({
+		hosts,
+		memory,
+		local: input.local,
+		lists,
+		locate,
+		listed() {
+			for (const check of waiting) check();
+		}
+	});
+	async function claim(remote, reviewId) {
+		if (await ownerOf(reviewId) === void 0) return `${reviewId} is not on ${remote.alias}'s list.`;
+	}
+	const pushes = createGatewayPushes({
+		hosts,
+		relay: input.relay,
+		claim,
+		log
+	});
+	const stopWatchingWindows = input.relay.onAttachedChange(() => {
+		if (!closed) pushes.changed();
+	});
+	return {
+		fetch: (request) => app.fetch(request),
+		setHosts: (list) => hosts.set(list),
+		hosts: () => hosts.states(),
+		async close() {
+			closed = true;
+			stopWatchingWindows();
+			streams.close();
+			pushes.close();
+			hosts.close();
+			await memory.flush();
+		}
+	};
+}
+//#endregion
 //#region src/server/review-lifecycle-telemetry.ts
 /**
 * Review created, published and revoked, and agent authoring completed, as
@@ -808,154 +2387,7 @@ var ReviewOpenWatchdog = class {
 	}
 };
 //#endregion
-//#region src/server/tutorial-service.ts
-const authoredSchema = z.strictObject({
-	title: z.string().min(1),
-	document: documentSchema
-});
-const lensesSchema = z.array(lensSchema.omit({ id: true }));
-const pinsSchema = z.strictObject({
-	base: z.string().regex(/^[a-f0-9]{40}$/),
-	head: z.string().regex(/^[a-f0-9]{40}$/)
-});
-const stampSchema = z.object({
-	version: z.literal(10),
-	reviewUuid: z.string(),
-	contentHash: z.string()
-});
-async function readTutorialAssets(assetsRoot) {
-	const bytes = await Promise.all([
-		"document.json",
-		"lenses.json",
-		"pins.json"
-	].map((name) => readFile(path.join(assetsRoot, name), "utf8")));
-	return {
-		authored: authoredSchema.parse(JSON.parse(bytes[0])),
-		lenses: lensesSchema.parse(JSON.parse(bytes[1])),
-		pins: pinsSchema.parse(JSON.parse(bytes[2])),
-		contentHash: createHash("sha256").update(JSON.stringify(bytes)).digest("hex")
-	};
-}
-/** Create the shipped document through the same strict validation as authored reviews. */
-async function createNativeTutorial(input) {
-	const assets = await readTutorialAssets(input.assetsRoot);
-	const repository = await input.data.register(input.sampleRoot);
-	const pins = await input.data.resolvePins(repository.id, assets.pins.base, assets.pins.head);
-	const result = await input.store.execute({ operation: {
-		type: "create",
-		title: assets.authored.title,
-		target: {
-			kind: "commits",
-			...pins
-		}
-	} }, {
-		document: assets.authored.document,
-		origin: { tutorial: true }
-	});
-	for (const { title, targets } of assets.lenses) await input.store.execute({ operation: {
-		type: "lens_edit",
-		reviewId: result.reviewId,
-		edit: {
-			type: "insert",
-			title,
-			targets
-		}
-	} });
-	return {
-		snapshot: input.store.read(result.reviewId),
-		contentHash: assets.contentHash
-	};
-}
-function createTutorialService(input) {
-	const tutorialRoot = path.join(devReviewHome(), "tutorial");
-	const sampleRoot = path.join(tutorialRoot, "sample-service");
-	const stampPath = path.join(tutorialRoot, "stamp.json");
-	const assetsRoot = path.join(input.packageRoot, "tutorial");
-	const readStamp = async () => stampSchema.safeParse(await readFile(stampPath, "utf8").then((value) => JSON.parse(value)).catch(() => null)).data;
-	async function find() {
-		try {
-			const stamp = await readStamp();
-			if (!stamp || !input.store.has(stamp.reviewUuid)) return null;
-			const snapshot = input.store.read(stamp.reviewUuid);
-			const assets = await readTutorialAssets(assetsRoot);
-			const [head, base] = await Promise.all([resolveRevision(sampleRoot, "HEAD"), resolveRevision(sampleRoot, "HEAD^")]);
-			return snapshot.origin?.tutorial && stamp.contentHash === assets.contentHash && head && base && snapshot.pins?.head === head.commit && snapshot.pins?.base === base.commit && head.commit === assets.pins.head && base.commit === assets.pins.base ? snapshot : null;
-		} catch {
-			return null;
-		}
-	}
-	async function cleanup() {
-		for (const reviewId of input.store.tutorialIds()) {
-			if (!input.store.read(reviewId).trashedAt) await input.store.execute({ operation: {
-				type: "lifecycle",
-				state: "trash",
-				reviewId
-			} });
-			await input.store.execute({ operation: {
-				type: "delete",
-				reviewId
-			} });
-		}
-		for (const repository of input.store.repositories()) {
-			const relative = path.relative(tutorialRoot, repository.path);
-			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) await input.data.forgetRepository(repository.id);
-		}
-		await rm(tutorialRoot, {
-			recursive: true,
-			force: true,
-			maxRetries: 10
-		});
-	}
-	return {
-		async status() {
-			return {
-				version: 1,
-				reviewUuid: (await find())?.reviewId ?? null
-			};
-		},
-		async referencesReview(id) {
-			return input.store.has(id) && input.store.read(id).origin?.tutorial === true;
-		},
-		async prepare(options) {
-			const current = await find();
-			if (current) return current;
-			await readTutorialAssets(assetsRoot);
-			await options?.beforeReset();
-			await cleanup();
-			await mkdir(tutorialRoot, {
-				recursive: true,
-				mode: 448
-			});
-			const temporaryRoot = path.join(tutorialRoot, `.sample-service-${randomUUID()}`);
-			try {
-				await cp(path.join(assetsRoot, "sample-service"), temporaryRoot, { recursive: true });
-				await cp(path.join(assetsRoot, "git-stub"), path.join(temporaryRoot, ".git"), { recursive: true });
-				await rename(temporaryRoot, sampleRoot);
-				const { snapshot, contentHash } = await createNativeTutorial({
-					assetsRoot,
-					sampleRoot,
-					store: input.store,
-					data: input.data
-				});
-				await writePrivateJsonAtomic(stampPath, {
-					version: 10,
-					reviewUuid: snapshot.reviewId,
-					contentHash
-				});
-				return snapshot;
-			} finally {
-				await rm(temporaryRoot, {
-					recursive: true,
-					force: true
-				});
-			}
-		},
-		cleanup
-	};
-}
-//#endregion
 //#region src/server/desktop-server.ts
-const TUTORIAL_LIFECYCLE_LOCK_KEY = "tutorial-lifecycle";
 function createGlobalReviewServer(input) {
 	const instanceId = input.instanceId ?? crypto.randomUUID();
 	const token = input.token ?? crypto.randomBytes(32).toString("base64url");
@@ -968,42 +2400,13 @@ function createGlobalReviewServer(input) {
 	const discoveryPaths = input.discoveryPath ? [input.discoveryPath] : identity.key === "stable" ? [reviewInstanceDiscoveryPath("stable"), reviewLegacyDiscoveryPath()] : [reviewInstanceDiscoveryPath(identity.key)];
 	const telemetry = input.telemetry ?? ReviewTelemetry.fromEnv();
 	const relay = input.relay ?? new GlobalReviewDesktopVerbRelay({ maxClients: 1 });
-	const askCliEnv = () => [
-		{
-			name: REVIEW_INSTANCE_ENV,
-			value: identity.key
-		},
-		...process.versions.electron ? [{
-			name: "ELECTRON_RUN_AS_NODE",
-			value: "1"
-		}] : [],
-		...process.env.DEV_REVIEW_HOME ? [{
-			name: "DEV_REVIEW_HOME",
-			value: process.env.DEV_REVIEW_HOME
-		}] : []
-	];
-	const askTools = {
-		mcpServers: () => discovery.cliPath ? [{
-			name: "whiteboard",
-			command: process.execPath,
-			args: [discovery.cliPath, "mcp"],
-			env: askCliEnv()
-		}] : [],
-		cli: () => discovery.cliPath && [
-			...askCliEnv().map(({ name, value }) => `${name}=${shellQuote(value)}`),
-			shellQuote(process.execPath),
-			shellQuote(discovery.cliPath)
-		].join(" ")
-	};
+	const askTools = cliAskTools(() => discovery.cliPath, {
+		name: REVIEW_INSTANCE_ENV,
+		value: identity.key
+	});
 	const reviewStore = input.reviewStore;
-	const reviewLocks = /* @__PURE__ */ new Map();
 	let appReadyReported = false;
 	const openWatchdog = new ReviewOpenWatchdog({ onTimeout: (context, elapsedMs) => void telemetry.captureEvent("review_open_timeout", { elapsed_ms: elapsedMs }, context) });
-	const tutorial = createTutorialService({
-		packageRoot: input.packageRoot,
-		store: reviewStore,
-		data: input.reviewData
-	});
 	let closing = false;
 	const cliPath = path.join(input.packageRoot, "dist", "cli.js");
 	let scratchpadEnabled = false;
@@ -1049,8 +2452,22 @@ function createGlobalReviewServer(input) {
 		ask: { tools: askTools }
 	});
 	const { app } = core;
-	app.route("/reviews-api", createJsonReviewReporting(input.reviewStore, telemetry, { shared: input.sharedReviews }));
-	app.route("/reviews-api", core.api);
+	const localApi = new Hono();
+	answerErrorsAsJson(localApi);
+	localApi.route("/reviews-api", createJsonReviewReporting(input.reviewStore, telemetry, { shared: input.sharedReviews }));
+	localApi.route("/reviews-api", core.api);
+	const gateway = createReviewGateway({
+		local: (request) => localApi.fetch(request),
+		isLocal: (reviewId) => reviewStore.has(reviewId),
+		version: readReviewPackageVersion(import.meta.url),
+		home: devReviewHome(),
+		relay,
+		restarted: (alias) => input.onRemoteHostRestarted?.(alias),
+		log: input.log
+	});
+	app.all("/reviews-api", (context) => gateway.fetch(context.req.raw));
+	app.all("/reviews-api/*", (context) => gateway.fetch(context.req.raw));
+	app.get("/remote-hosts", () => serverJson(200, gateway.hosts()));
 	app.get("/preferences/scratchpad", () => serverJson(200, { enabled: scratchpadEnabled }));
 	app.put("/preferences/scratchpad", async (context) => {
 		const request = z.object({ enabled: z.boolean() }).safeParse(await readBoundedRequestJson(context.req.raw));
@@ -1100,21 +2517,6 @@ function createGlobalReviewServer(input) {
 		const result = await reportCrashDump(telemetry, body.data, input.crashDumpsDir);
 		return serverJson(result.status, result.body);
 	});
-	app.get("/tutorial/status", async () => serverJson(200, await tutorial.status()));
-	app.post("/tutorial/prepare", async () => {
-		const prepared = await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, prepareTutorialLocked);
-		return serverJson(200, {
-			ok: true,
-			reviewUuid: prepared.reviewId
-		});
-	});
-	app.post("/tutorial/open", async () => {
-		return serverJson(200, await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, openTutorialLocked));
-	});
-	app.delete("/tutorial", async () => {
-		await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, deleteTutorialLocked);
-		return serverJson(200, { ok: true });
-	});
 	app.get("/diffr-config", async () => serverJson(200, await readDiffrConfig()));
 	app.put("/diffr-config", async (context) => {
 		const body = await readBoundedRequestJson(context.req.raw);
@@ -1184,37 +2586,13 @@ function createGlobalReviewServer(input) {
 		await resetCliInstall();
 		return serverJson(200, { ok: true });
 	});
+	app.get("/install/agents", async () => serverJson(200, { agents: await detectConnectAgents() }));
+	app.post("/install/connect", async (context) => {
+		const request = ReviewConnectRequestSchema.safeParse(await readBoundedRequestJson(context.req.raw));
+		if (!request.success) throw new ReviewServerError("Invalid agent.", 400);
+		return serverJson(200, await connectAgent(request.data.target, { hasShim: existsSync(pathShimPath()) }));
+	});
 	const httpServer = createServer(createNodeRequestListener(app));
-	async function prepareTutorialLocked() {
-		return tutorial.prepare();
-	}
-	async function openTutorialLocked() {
-		const snapshot = await prepareTutorialLocked();
-		return {
-			kind: "api",
-			reviewUuid: snapshot.reviewId,
-			title: snapshot.title
-		};
-	}
-	async function deleteTutorialLocked() {
-		await tutorial.cleanup();
-	}
-	async function withReviewLock(reviewUuid, operation) {
-		const previous = reviewLocks.get(reviewUuid) ?? Promise.resolve();
-		let release = () => {};
-		const current = new Promise((resolve) => {
-			release = resolve;
-		});
-		const chain = previous.then(() => current);
-		reviewLocks.set(reviewUuid, chain);
-		await previous;
-		try {
-			return await operation();
-		} finally {
-			release();
-			if (reviewLocks.get(reviewUuid) === chain) reviewLocks.delete(reviewUuid);
-		}
-	}
 	return {
 		discovery,
 		get url() {
@@ -1222,6 +2600,10 @@ function createGlobalReviewServer(input) {
 		},
 		listen: async () => {
 			await migrateDiffrConfig();
+			await removeLegacyTutorial({
+				store: reviewStore,
+				data: input.reviewData
+			});
 			scratchpadEnabled = await readScratchpadEnabled();
 			boundPort = await listen(httpServer, input.port);
 			discovery.url = urlForBoundPort();
@@ -1235,8 +2617,10 @@ function createGlobalReviewServer(input) {
 			relay.close();
 			openWatchdog.dispose();
 			await closeHttpServer(httpServer);
+			await gateway.close();
 			await telemetry.shutdown(1500);
-		}
+		},
+		setRemoteHosts: (hosts) => gateway.setHosts(hosts)
 	};
 }
 function watchSessionOpen(watchdog, event, context) {
@@ -1332,25 +2716,38 @@ async function runDesktopHost(env = process.env) {
 	};
 	const home = devReviewHome(env);
 	await mkdir(home, { recursive: true });
-	const local = await openReviewProfile(home, { manageWorkspaces: true });
-	const shared = new SharedReviewStore(path.join(home, "shared-reviews"));
-	shared.connect(local.store, local.data);
-	await shared.load();
-	const server = createGlobalReviewServer({
-		...serverInput,
-		sharedReviews: shared,
-		reviewStore: local.store,
-		reviewData: local.data,
-		cliRuntimePath: env.DEV_FAST_REVIEW_CLI_RUNTIME,
-		crashDumpsDir: env.DEV_FAST_REVIEW_CRASH_DUMPS_DIR
+	const log = (message) => process.stdout.write(`[Whiteboard gateway] ${message}\n`);
+	const { local, shared, server } = await takeOverServerHome(home, async () => {
+		const local = await openReviewProfile(home, { manageWorkspaces: true });
+		const shared = new SharedReviewStore(path.join(home, "shared-reviews"));
+		shared.connect(local.store, local.data);
+		await shared.load();
+		const server = createGlobalReviewServer({
+			...serverInput,
+			log,
+			sharedReviews: shared,
+			reviewStore: local.store,
+			reviewData: local.data,
+			cliRuntimePath: env.DEV_FAST_REVIEW_CLI_RUNTIME,
+			crashDumpsDir: env.DEV_FAST_REVIEW_CRASH_DUMPS_DIR,
+			onRemoteHostRestarted: (alias) => postToDesktop(process, {
+				type: "remote-host-restarted",
+				alias
+			})
+		});
+		try {
+			await server.listen();
+		} catch (error) {
+			await local?.data.close();
+			await local?.store.close();
+			throw error;
+		}
+		return {
+			local,
+			shared,
+			server
+		};
 	});
-	try {
-		await server.listen();
-	} catch (error) {
-		await local?.data.close();
-		await local?.store.close();
-		throw error;
-	}
 	process.stdout.write(`${JSON.stringify({
 		event: "ready",
 		...server.discovery,
@@ -1373,7 +2770,7 @@ async function runDesktopHost(env = process.env) {
 	}, (sourcePath) => {
 		env.DEV_FAST_REVIEW_RUST_ANALYZER = sourcePath;
 		stageRustAnalyzer();
-	});
+	}, (hosts) => server.setRemoteHosts(hosts));
 	process.once("SIGINT", () => {
 		stop().then(() => process.exit(0));
 	});