@krelborn/markdown-review 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,3322 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { parseArgs, promisify } from "node:util";
+import { execFile, spawn } from "node:child_process";
+import { mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import path from "node:path";
+import { z } from "zod";
+import os from "node:os";
+import openInBrowser from "open";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { getRequestListener } from "@hono/node-server";
+import { Hono } from "hono";
+import { stream, streamSSE } from "hono/streaming";
+import { tasklist } from "@mdit/plugin-tasklist";
+import markdownIt from "markdown-it";
+import search from "approx-string-match";
+import { watch } from "chokidar";
+//#region src/cli/createProcessTerminal.ts
+/**
+* Connects a CLI invocation to this process's working directory, environment and standard streams
+*/
+function createProcessTerminal() {
+	return {
+		workingDirectory: process.cwd(),
+		env: process.env,
+		readStdin: async () => {
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+			return Buffer.concat(chunks).toString("utf8");
+		},
+		stderr: (text) => {
+			process.stderr.write(text);
+		},
+		stdout: (text) => {
+			process.stdout.write(text);
+		}
+	};
+}
+//#endregion
+//#region src/server/runtime/packageVersion.ts
+var packageVersion = {
+	name: "@krelborn/markdown-review",
+	version: "0.1.0",
+	description: "Review agent-written markdown in the browser and hand the comments back to the agent",
+	license: "MIT",
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/Krelborn/markdown-review.git"
+	},
+	bin: { "markdown-review": "dist/cli.js" },
+	files: ["dist"],
+	type: "module",
+	publishConfig: {
+		"@krelborn:registry": "https://registry.npmjs.org/",
+		"access": "public"
+	},
+	scripts: {
+		"build": "vite build && vite build --config vite.web.config.mts",
+		"typecheck": "tsc -b",
+		"lint": "oxlint",
+		"format": "oxfmt",
+		"format:check": "oxfmt --check",
+		"test": "vitest run",
+		"test:coverage": "pnpm test --coverage",
+		"test:watch": "vitest",
+		"verify": "pnpm lint && pnpm format:check && pnpm typecheck && pnpm test",
+		"prepare": "husky",
+		"prepublishOnly": "pnpm build",
+		"test:e2e": "playwright test"
+	},
+	dependencies: {
+		"@hono/node-server": "^2.1.4",
+		"@mdit/plugin-tasklist": "^1.1.3",
+		"approx-string-match": "^2.0.0",
+		"chokidar": "^5.0.0",
+		"hono": "^4.13.13",
+		"markdown-it": "^15.0.2",
+		"open": "^11.0.4",
+		"zod": "^4.6.5"
+	},
+	devDependencies: {
+		"@babel/core": "^8.0.7",
+		"@krelborn/stylesui": "^0.2.1",
+		"@playwright/test": "^1.64.0",
+		"@rolldown/plugin-babel": "^0.2.4",
+		"@testing-library/dom": "^10.4.2",
+		"@testing-library/jest-dom": "^7.0.1",
+		"@testing-library/react": "^16.3.3",
+		"@testing-library/user-event": "^14.6.7",
+		"@types/node": "^26.6.4",
+		"@types/react": "^19.3.0",
+		"@types/react-dom": "^19.3.0",
+		"@vitejs/plugin-react": "^6.1.2",
+		"@vitest/coverage-v8": "^5.0.3",
+		"babel-plugin-react-compiler": "^1.0.0",
+		"clsx": "^2.1.1",
+		"dompurify": "^3.4.16",
+		"fallow": "^3.32.0",
+		"husky": "^9.1.7",
+		"jsdom": "^30.1.2",
+		"lint-staged": "^17.6.0",
+		"mermaid": "^12.1.0",
+		"oxfmt": "^0.72.0",
+		"oxlint": "^1.87.0",
+		"react": "^19.3.0",
+		"react-dom": "^19.3.0",
+		"shiki": "^4.5.0",
+		"typescript": "^7.0.2",
+		"vite": "^8.3.3",
+		"vitest": "^5.0.3"
+	},
+	engines: { "node": "^22.22.2 || ^24.15.0 || >=26.0.0" },
+	packageManager: "pnpm@10.18.3"
+}.version;
+//#endregion
+//#region src/cli/CliError.ts
+/**
+* A command that cannot finish, with the `next_step` that tells the agent what to do about it
+*/
+var CliError = class extends Error {
+	exitCode;
+	nextStep;
+	constructor(message, nextStep, exitCode = 1) {
+		super(message);
+		this.name = "CliError";
+		this.exitCode = exitCode;
+		this.nextStep = nextStep;
+	}
+};
+//#endregion
+//#region src/server/store/storePaths.ts
+var storeDirectoryName = ".markdown-review";
+function storeDirectory(root) {
+	return path.join(root, storeDirectoryName);
+}
+function reviewFilePath(root) {
+	return path.join(storeDirectory(root), "review.json");
+}
+function serverFilePath(root) {
+	return path.join(storeDirectory(root), "server.json");
+}
+function serverLockPath(root) {
+	return path.join(storeDirectory(root), "server.lock");
+}
+function serverLogPath(root) {
+	return path.join(storeDirectory(root), "server.log");
+}
+function documentsDirectory(root) {
+	return path.join(storeDirectory(root), "documents");
+}
+/**
+* Locates the file holding a doc's threads
+*
+* @param root the repo root
+* @param document a repo-relative POSIX path, e.g. "docs/plan.md"
+* @returns where the doc's threads are stored, e.g. "<root>/.markdown-review/documents/docs/plan.md.json"
+*/
+function documentThreadsFilePath(root, document) {
+	return path.join(documentsDirectory(root), ...`${document}.json`.split("/"));
+}
+/**
+* Locates a doc's source on disk
+*
+* @param root the repo root
+* @param document a repo-relative POSIX path
+* @returns the doc's path on disk
+*/
+function documentSourcePath(root, document) {
+	return path.join(root, ...document.split("/"));
+}
+//#endregion
+//#region src/server/runtime/serverFileSchema.ts
+/**
+* `.markdown-review/server.json`: how the CLI finds and authenticates to the root's running server
+*
+* Not strict, so a newer server that records more fields is still recognised by its protocol rather than mistaken for
+* no server
+*/
+var serverFileSchema = z.object({
+	pid: z.int(),
+	port: z.int().min(1).max(65535),
+	protocol: z.int(),
+	root: z.string(),
+	startedAt: z.iso.datetime(),
+	token: z.string().regex(/^[0-9a-f]{64}$/),
+	version: z.string()
+});
+//#endregion
+//#region src/server/files/isFileNotFound.ts
+/**
+* Tells whether a file system error means the file does not exist
+*
+* @param error the error a file system call rejected with
+* @returns true for ENOENT
+*/
+function isFileNotFound(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/server/files/readTextFileOrNull.ts
+/**
+* Reads a UTF-8 text file
+*
+* @param filePath the file to read
+* @returns the contents, or null when the file does not exist
+* @throws the file system error when the file exists but cannot be read
+*/
+async function readTextFileOrNull(filePath) {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isFileNotFound(error)) return null;
+		throw error;
+	}
+}
+//#endregion
+//#region src/server/store/readStoreFile.ts
+/**
+* Reads and validates a store file
+*
+* @param filePath the file to read
+* @param schema the shape the file must have
+* @returns the file's value, null when the file does not exist, or a description of what is wrong with it
+* @throws the file system error when the file exists but cannot be read
+*/
+async function readStoreFile(filePath, schema) {
+	const contents = await readTextFileOrNull(filePath);
+	if (contents === null) return {
+		kind: "valid",
+		value: null
+	};
+	let value;
+	try {
+		value = JSON.parse(contents);
+	} catch (error) {
+		return {
+			kind: "invalid",
+			problem: `${filePath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	const result = schema.safeParse(value);
+	if (!result.success) return {
+		kind: "invalid",
+		problem: `${filePath} is not a valid store file:\n${z.prettifyError(result.error)}`
+	};
+	return {
+		kind: "valid",
+		value: result.data
+	};
+}
+//#endregion
+//#region src/shared/review/isRepositoryRelativePath.ts
+/**
+* Tells whether a path names a file inside the repo without leaving it
+*
+* @param value the path to check
+* @returns true for a relative POSIX path with no empty, "." or ".." segments
+*/
+function isRepositoryRelativePath(value) {
+	if (value === "" || value.startsWith("/") || value.includes("\\")) return false;
+	return value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+var documentPathSchema = z.string().refine(isRepositoryRelativePath, "must be a repo-relative POSIX path");
+var reviewAnchorSchema = z.strictObject({ kind: z.literal("review") });
+var documentAnchorSchema = z.strictObject({
+	document: documentPathSchema,
+	kind: z.literal("document")
+});
+var passageAnchorSchema = z.strictObject({
+	anchoredText: z.string().min(1),
+	document: documentPathSchema,
+	endLine: z.int().positive(),
+	endOffset: z.int().nonnegative(),
+	kind: z.literal("passage"),
+	outdated: z.boolean(),
+	prefix: z.string().max(32),
+	quote: z.string().min(1),
+	startLine: z.int().positive(),
+	startOffset: z.int().nonnegative(),
+	suffix: z.string().max(32)
+}).refine((anchor) => anchor.startLine <= anchor.endLine && anchor.startOffset <= anchor.endOffset, { message: "must not end before it starts" });
+var anchorSchema = z.discriminatedUnion("kind", [
+	reviewAnchorSchema,
+	documentAnchorSchema,
+	passageAnchorSchema
+]);
+//#endregion
+//#region src/shared/review/threadSchema.ts
+var messageBodySchema = z.string().refine((body) => body.trim() !== "", "must not be blank");
+var messageSchema = z.strictObject({
+	at: z.iso.datetime(),
+	author: z.enum(["user", "agent"]),
+	body: messageBodySchema
+});
+var draftMessageSchema = z.strictObject({
+	at: z.iso.datetime(),
+	body: messageBodySchema
+});
+var threadSchema = z.strictObject({
+	anchor: anchorSchema,
+	createdAt: z.iso.datetime(),
+	draft: draftMessageSchema.optional(),
+	id: z.int().positive(),
+	messages: z.array(messageSchema),
+	status: z.enum([
+		"draft",
+		"open",
+		"resolved"
+	]),
+	updatedAt: z.iso.datetime()
+}).refine((thread) => thread.status === "draft" === (thread.messages.length === 0), { message: "must have messages unless it is a draft" }).refine((thread) => thread.status !== "draft" || thread.draft !== void 0, { message: "must hold its comment as a draft while it is a draft" });
+//#endregion
+//#region src/shared/api/apiResponseSchemas.ts
+var reviewStateSchema = z.strictObject({
+	approved: z.boolean(),
+	approvedAt: z.iso.datetime().nullable(),
+	requestedAt: z.iso.datetime().nullable()
+});
+/**
+* Not strict, so a newer server that reports more fields is still recognised by its protocol rather than mistaken for
+* no server
+*/
+var healthSchema = z.object({
+	name: z.literal("markdown-review"),
+	pid: z.int(),
+	protocol: z.int(),
+	root: z.string(),
+	version: z.string()
+});
+var threadsSnapshotSchema = z.strictObject({
+	problems: z.array(z.string()),
+	review: reviewStateSchema,
+	threads: z.array(threadSchema)
+});
+var pollResponseSchema = threadsSnapshotSchema.extend({ timedOut: z.boolean() });
+var agentOpenResponseSchema = z.strictObject({
+	navigated: z.boolean(),
+	review: reviewStateSchema,
+	url: z.string()
+});
+var agentThreadResponseSchema = z.strictObject({
+	inbox: threadsSnapshotSchema,
+	thread: threadSchema
+});
+var shutdownResponseSchema = z.strictObject({ stopping: z.literal(true) });
+z.strictObject({
+	documents: z.array(z.strictObject({
+		document: documentPathSchema,
+		draftCount: z.int().nonnegative(),
+		openCount: z.int().nonnegative()
+	})),
+	problems: z.array(z.string()),
+	recent: z.array(documentPathSchema)
+});
+z.strictObject({
+	hash: z.string(),
+	path: documentPathSchema,
+	source: z.string()
+});
+var apiErrorSchema = z.strictObject({ error: z.strictObject({
+	message: z.string(),
+	reason: z.string()
+}) });
+//#endregion
+//#region src/cli/ServerRequestError.ts
+/**
+* A request the review server refused or answered with something the CLI cannot read
+*/
+var ServerRequestError = class extends Error {
+	reason;
+	status;
+	constructor(status, reason, message) {
+		super(message);
+		this.name = "ServerRequestError";
+		this.reason = reason;
+		this.status = status;
+	}
+};
+//#endregion
+//#region src/cli/ServerClient.ts
+var healthTimeoutMilliseconds = 1e3;
+/**
+* Talks to one root's review server on behalf of the agent
+*/
+var ServerClient = class {
+	port;
+	token;
+	constructor(port, token) {
+		this.port = port;
+		this.token = token;
+	}
+	/**
+	* @throws when nothing answers on the port within a second
+	*/
+	health() {
+		return this.request("GET", "/api/health", healthSchema, { signal: AbortSignal.timeout(healthTimeoutMilliseconds) });
+	}
+	open(document) {
+		return this.request("POST", "/api/agent/open", agentOpenResponseSchema, { body: document === null ? {} : { path: document } });
+	}
+	inbox(document) {
+		return this.request("GET", `/api/inbox${documentQuery(document)}`, threadsSnapshotSchema);
+	}
+	/**
+	* Waits for the review to be approved, a thread to need the agent, or the timeout
+	*/
+	poll(document, timeoutSeconds, signal) {
+		const query = new URLSearchParams({ timeout: String(timeoutSeconds) });
+		if (document !== null) query.set("document", document);
+		return this.request("GET", `/api/poll?${query}`, pollResponseSchema, { signal });
+	}
+	reply(id, body) {
+		return this.request("POST", `/api/agent/threads/${id}/reply`, agentThreadResponseSchema, { body: { body } });
+	}
+	resolve(id, body) {
+		return this.request("POST", `/api/agent/threads/${id}/resolve`, agentThreadResponseSchema, { body: { body } });
+	}
+	async shutdown() {
+		await this.request("POST", "/api/shutdown", shutdownResponseSchema);
+	}
+	async request(method, path, schema, { body, signal } = {}) {
+		const response = await fetch(`http://127.0.0.1:${this.port}${path}`, {
+			body: body === void 0 ? void 0 : JSON.stringify(body),
+			headers: {
+				authorization: `Bearer ${this.token}`,
+				"content-type": "application/json"
+			},
+			method,
+			signal
+		});
+		const text = await response.text();
+		const value = parseJson(text);
+		const refusal = apiErrorSchema.safeParse(value);
+		if (!response.ok || refusal.success) {
+			const { message, reason } = refusal.data?.error ?? {
+				message: text,
+				reason: "unknown"
+			};
+			throw new ServerRequestError(response.status, reason, message);
+		}
+		const result = schema.safeParse(value);
+		if (!result.success) throw new ServerRequestError(response.status, "unreadable-response", `${method} ${path} answered with ${text}`);
+		return result.data;
+	}
+};
+function documentQuery(document) {
+	return document === null ? "" : `?${new URLSearchParams({ document })}`;
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/cli/findServer.ts
+/**
+* Looks for a server already serving the root, using `.markdown-review/server.json`
+*
+* @param root the root's real path
+* @returns "ready" for a healthy server of this protocol, "older" or "newer" for one of another protocol, and
+*   "absent" when there is no record, the recorded server does not answer, or it serves another root
+*/
+async function findServer(root) {
+	const recorded = await readStoreFile(serverFilePath(root), serverFileSchema);
+	if (recorded.kind === "invalid" || recorded.value === null) return { kind: "absent" };
+	const client = new ServerClient(recorded.value.port, recorded.value.token);
+	let health;
+	try {
+		health = await client.health();
+	} catch {
+		return { kind: "absent" };
+	}
+	if (health.root !== root) return { kind: "absent" };
+	if (health.protocol < 1) return {
+		client,
+		kind: "older"
+	};
+	return health.protocol > 1 ? {
+		health,
+		kind: "newer"
+	} : {
+		client,
+		kind: "ready"
+	};
+}
+//#endregion
+//#region src/cli/withStartLock.ts
+var lockWaitMilliseconds = 15e3;
+var lockRetryMilliseconds = 100;
+/**
+* Runs a task while holding `.markdown-review/server.lock`, so only one command at a time starts the root's server
+*
+* @param root the root's real path; its `.markdown-review/` directory must exist
+* @param task what to do while holding the lock
+* @returns the task's result
+* @throws CliError when another live process holds the lock for longer than 15 seconds
+*/
+async function withStartLock(root, task) {
+	const lockPath = serverLockPath(root);
+	const deadline = Date.now() + lockWaitMilliseconds;
+	while (!await tryCreateLock(lockPath)) {
+		if (await removeStaleLock(lockPath)) continue;
+		if (Date.now() > deadline) throw new CliError(`Another markdown-review command has been starting the server for ${root} for over 15 seconds`, `Wait for it to finish, or delete ${lockPath} if no other markdown-review command is running, then try again.`);
+		await setTimeout$1(lockRetryMilliseconds);
+	}
+	try {
+		return await task();
+	} finally {
+		await rm(lockPath, { force: true });
+	}
+}
+async function tryCreateLock(lockPath) {
+	try {
+		await writeFile(lockPath, String(process.pid), { flag: "wx" });
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") return false;
+		throw error;
+	}
+}
+/**
+* Removes the lock when its owner has exited without removing it. Commands check and remove it one at a time, under
+* a second lock, so a command that found the lock stale cannot then remove the lock another command has just taken.
+*
+* @returns whether the lock was removed
+*/
+async function removeStaleLock(lockPath) {
+	const checkPath = `${lockPath}.check`;
+	if (!await tryCreateLock(checkPath)) {
+		if (await isStaleLock(checkPath)) await rm(checkPath, { force: true });
+		return false;
+	}
+	try {
+		if (!await isStaleLock(lockPath)) return false;
+		await rm(lockPath, { force: true });
+		return true;
+	} finally {
+		await rm(checkPath, { force: true });
+	}
+}
+/**
+* Tells whether the lock's owner has exited without removing it
+*/
+async function isStaleLock(lockPath) {
+	let owner;
+	try {
+		owner = Number(await readFile(lockPath, "utf8"));
+	} catch {
+		return false;
+	}
+	if (!Number.isInteger(owner) || owner <= 0) return false;
+	try {
+		process.kill(owner, 0);
+		return false;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "ESRCH";
+	}
+}
+//#endregion
+//#region src/cli/connectToServer.ts
+var startWaitMilliseconds = 1e4;
+var stopWaitMilliseconds = 5e3;
+var checkIntervalMilliseconds = 100;
+/**
+* Connects to the root's review server, starting one when none is running and replacing one of an older protocol
+*
+* @param root the root's real path
+* @param cliPath the built CLI, which the server is started from
+* @returns a client for the running server
+* @throws CliError when a newer markdown-review is serving the root, or the server does not start
+*/
+async function connectToServer(root, cliPath) {
+	const found = await findServer(root);
+	switch (found.kind) {
+		case "ready": return found.client;
+		case "newer": throw new CliError(`A newer markdown-review (version ${found.health.version}, protocol ${found.health.protocol}) is serving ${root}`, "Run the newer markdown-review, for example `npx @krelborn/markdown-review@latest <command>`, or stop its server with it.");
+		case "older":
+			await found.client.shutdown();
+			await waitUntilStopped(found.client);
+	}
+	await mkdir(storeDirectory(root), { recursive: true });
+	return withStartLock(root, async () => {
+		const recheck = await findServer(root);
+		if (recheck.kind === "ready") return recheck.client;
+		await spawnServer(root, cliPath);
+		return waitUntilReady(root);
+	});
+}
+/**
+* Waits for a server to stop answering, after asking it to shut down
+*
+* @param client the server's client
+*/
+async function waitUntilStopped(client) {
+	const deadline = Date.now() + stopWaitMilliseconds;
+	while (Date.now() < deadline) {
+		try {
+			await client.health();
+		} catch {
+			return;
+		}
+		await setTimeout$1(checkIntervalMilliseconds);
+	}
+}
+async function spawnServer(root, cliPath) {
+	const log = await open(serverLogPath(root), "a");
+	try {
+		spawn(process.execPath, [
+			cliPath,
+			"serve",
+			"--root",
+			root
+		], {
+			detached: true,
+			stdio: [
+				"ignore",
+				log.fd,
+				log.fd
+			]
+		}).unref();
+	} finally {
+		await log.close();
+	}
+}
+async function waitUntilReady(root) {
+	const deadline = Date.now() + startWaitMilliseconds;
+	while (Date.now() < deadline) {
+		const found = await findServer(root);
+		if (found.kind === "ready") return found.client;
+		await setTimeout$1(checkIntervalMilliseconds);
+	}
+	throw new CliError(`The review server for ${root} did not start within 10 seconds`, `Read ${serverLogPath(root)}, fix what it reports, and run the command again.`);
+}
+//#endregion
+//#region src/cli/findRoot.ts
+var runCommand = promisify(execFile);
+/**
+* Finds the root a directory's reviews belong to
+*
+* @param directory an existing directory
+* @param outsideGitDirectory the root to use when `directory` is not in a git repository; `directory` itself unless
+*   given
+* @returns the real path of the git repository (or worktree) root holding the directory, or of `outsideGitDirectory`
+*   when it is not in a git repository
+*/
+async function findRoot(directory, outsideGitDirectory = directory) {
+	try {
+		const { stdout } = await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd: directory });
+		return await realpath(stdout.trim());
+	} catch {
+		return realpath(outsideGitDirectory);
+	}
+}
+//#endregion
+//#region src/cli/formatIdList.ts
+/**
+* Lists thread IDs the way the CLI's sentences name them
+*
+* @param ids the thread IDs, in the order to list them
+* @returns e.g. "#14", "#14 and #15", or "#14, #15 and #16"
+*/
+function formatIdList(ids) {
+	const names = ids.map((id) => `#${id}`);
+	const last = names.pop();
+	if (last === void 0) return "";
+	return names.length === 0 ? last : `${names.join(", ")} and ${last}`;
+}
+//#endregion
+//#region src/cli/nextSteps.ts
+var pollTimeoutAdvice = "Give the shell command a timeout of at least 600000 ms, or in Claude Code run it with run_in_background and `--timeout 7080`.";
+var waitForCommentsStep = `Run \`markdown-review poll\` to wait for the user's comments. ${pollTimeoutAdvice}`;
+/**
+* @param root the root of a doc opened from outside its repository
+*/
+function waitForCommentsInRootStep(root) {
+	return `This doc belongs to the repository at ${root}, so run markdown-review commands from that directory. ` + waitForCommentsStep;
+}
+var approvedStep = "The user approved the review. Carry on with your task; do not run `markdown-review poll` again for this review.";
+/**
+* @param ids the threads that need the agent, at least one
+*/
+function addressThreadsStep(ids) {
+	return `Edit the docs, then run \`markdown-review resolve <id> "<what changed>"\` for ${formatIdList(ids)}, or \`markdown-review reply <id> "<question>"\` if you need input. Then run \`markdown-review poll\` to wait for the next round.`;
+}
+/**
+* @param ids the threads the user commented on when approving, at least one
+*/
+function approvedWithCommentsStep(ids) {
+	const resolveCommand = ids.length === 1 ? `\`markdown-review resolve ${ids[0]} "<what changed>"\`` : "`markdown-review resolve <id> \"<what changed>\"` for each";
+	return `The user approved the review with comments. Address ${formatIdList(ids)} and run ${resolveCommand}, then carry on with your task; do not run \`markdown-review poll\` again for this review.`;
+}
+//#endregion
+//#region src/cli/formatAgentAction.ts
+/**
+* Confirms an agent reply or resolve and says what is left
+*
+* @param action what the agent did
+* @param response the thread after the action and the inbox that remains
+* @returns the confirmation, the threads still needing the agent, and a `next_step`
+*/
+function formatAgentAction(action, { inbox, thread }) {
+	const done = action === "resolved" ? `Resolved #${thread.id}.` : `Replied to #${thread.id}; it waits for the user.`;
+	const remaining = inbox.threads.map((remainingThread) => remainingThread.id);
+	if (remaining.length > 0) return `${done}\n${remaining.length === 1 ? "1 thread still needs you" : `${remaining.length} threads still need you`}: ${formatIdList(remaining)}.\n\nnext_step: Address ${formatIdList(remaining)}, then run \`markdown-review resolve <id> "<what changed>"\`, or \`markdown-review reply <id> "<question>"\` if you need input.
+`;
+	return `${done} No threads need you now.\n\nnext_step: ${inbox.review.approved ? approvedStep : "Run `markdown-review poll` to wait for the user's next round of comments."}\n`;
+}
+//#endregion
+//#region src/cli/readMessageBody.ts
+/**
+* Reads a reply or resolve message from the command's words or from `--file`
+*
+* @param words the words after the thread ID
+* @param file the `--file` option: a path, or "-" for standard input
+* @param terminal where standard input comes from
+* @returns the message, or null when neither was given
+*/
+async function readMessageBody(words, file, terminal) {
+	if (file === "-") return terminal.readStdin();
+	if (file !== void 0) return readFile(path.resolve(terminal.workingDirectory, file), "utf8");
+	return words.length === 0 ? null : words.join(" ");
+}
+//#endregion
+//#region src/cli/readThreadIdArgument.ts
+/**
+* @param value the command's first word
+* @param usage the command's usage line, for the error
+* @returns the thread ID
+* @throws CliError when the word is not a thread ID
+*/
+function readThreadIdArgument(value, usage) {
+	if (value === void 0 || !/^#?[1-9][0-9]*$/.test(value)) throw new CliError(`Expected a thread ID such as 14, not ${value ?? "nothing"}`, `Run \`${usage}\`.`, 2);
+	return Number(value.replace("#", ""));
+}
+//#endregion
+//#region src/cli/commands/agentThreadCommands.ts
+async function replyCommand(args, { cliPath, terminal }) {
+	const { id, message } = await readArguments(args, terminal, "markdown-review reply <id> \"<text>\"");
+	if (message === null) throw new CliError("reply needs the text of the reply", "Run `markdown-review reply <id> \"<text>\"`.", 2);
+	const client = await connectToServer(await findRoot(terminal.workingDirectory), cliPath);
+	const response = await explainUnknownThread(client, id, () => client.reply(id, message));
+	terminal.stdout(formatAgentAction("replied", response));
+	return 0;
+}
+async function resolveCommand(args, { cliPath, terminal }) {
+	const { id, message } = await readArguments(args, terminal, "markdown-review resolve <id> \"<what changed>\"");
+	const client = await connectToServer(await findRoot(terminal.workingDirectory), cliPath);
+	const response = await explainUnknownThread(client, id, () => client.resolve(id, message));
+	terminal.stdout(formatAgentAction("resolved", response));
+	return 0;
+}
+/**
+* Reads the thread ID and the message, before anything connects to the server
+*/
+async function readArguments(args, terminal, usage) {
+	const { positionals, values } = parseArgs({
+		allowPositionals: true,
+		args,
+		options: { file: { type: "string" } }
+	});
+	const [idWord, ...words] = positionals;
+	return {
+		id: readThreadIdArgument(idWord, usage),
+		message: await readMessageBody(words, values.file, terminal)
+	};
+}
+/**
+* Turns the server's "unknown thread" into an error that lists the threads the agent can act on
+*/
+async function explainUnknownThread(client, id, action) {
+	try {
+		return await action();
+	} catch (error) {
+		if (!(error instanceof ServerRequestError) || error.reason !== "unknown-thread") throw error;
+		const waiting = (await client.inbox(null)).threads.map((thread) => thread.id);
+		throw new CliError(`No thread #${id} is waiting for you. ${waiting.length === 0 ? "No threads need you." : `The threads that need you are ${formatIdList(waiting)}.`}`, "Run `markdown-review inbox` to see them.");
+	}
+}
+//#endregion
+//#region src/cli/formatInbox.ts
+var longQuoteLength = 200;
+var quoteStartLength = 120;
+/**
+* Describes the agent's inbox as compact text for the agent to read
+*
+* @param snapshot the review state and the threads that need the agent
+* @returns the summary, each thread grouped by doc with its messages, any store problems, and a final `next_step`
+*/
+function formatInbox({ problems, review, threads }) {
+	const ordered = orderByDocument(threads);
+	const ids = ordered.map((thread) => thread.id);
+	const sections = [summaryLine(review.approved, ordered)];
+	if (ordered.length > 0) sections.push(ordered.map(formatThread).join("\n\n"));
+	if (problems.length > 0) sections.push(problems.map((problem) => `warning: ${indentContinuation(problem, "  ")}`).join("\n"));
+	sections.push(`next_step: ${nextStep(review.approved, ids)}`);
+	return `${sections.join("\n\n")}\n`;
+}
+function formatThread(thread) {
+	const messages = thread.messages.map(({ author, body }) => `  ${author}: ${indentContinuation(body, "    ")}`);
+	return [...describeAnchor(thread), ...messages].join("\n");
+}
+/**
+* Says where the thread is, and for a passage, the text it quotes now and what the user originally selected
+*/
+function describeAnchor({ anchor, id }) {
+	switch (anchor.kind) {
+		case "review": return [`#${id} (whole review)`];
+		case "document": return [`#${id} ${anchor.document} (whole doc)`];
+		case "passage": {
+			const range = anchor.startLine === anchor.endLine ? `${anchor.startLine}` : `${anchor.startLine}-${anchor.endLine}`;
+			const location = `#${id} ${anchor.document}:${range}${anchor.outdated ? " (outdated)" : ""}`;
+			if (anchor.outdated) return [location, `  quote: ${formatQuote(anchor.quote)}`];
+			const original = anchor.anchoredText === anchor.quote ? [] : [`  was: ${formatQuote(anchor.quote)}`];
+			return [
+				location,
+				`  quote: ${formatQuote(anchor.anchoredText)}`,
+				...original
+			];
+		}
+	}
+}
+function summaryLine(approved, threads) {
+	if (threads.length === 0) return approved ? "Review approved. No threads need you." : "No threads need you.";
+	const counts = /* @__PURE__ */ new Map();
+	for (const thread of threads) {
+		const group = thread.anchor.kind === "review" ? "review" : thread.anchor.document;
+		counts.set(group, (counts.get(group) ?? 0) + 1);
+	}
+	const breakdown = [...counts].map(([group, count]) => `${group}: ${count}`).join(", ");
+	const needs = threads.length === 1 ? "1 thread needs you" : `${threads.length} threads need you`;
+	return approved ? `Review approved, ${needs} (${breakdown})` : `${needs} (${breakdown})`;
+}
+function nextStep(approved, ids) {
+	if (ids.length === 0) return approved ? approvedStep : waitForCommentsStep;
+	return approved ? approvedWithCommentsStep(ids) : addressThreadsStep(ids);
+}
+function orderByDocument(threads) {
+	const groupOf = (thread) => thread.anchor.kind === "review" ? "￿" : thread.anchor.document;
+	return [...threads].sort((left, right) => groupOf(left).localeCompare(groupOf(right)) || left.id - right.id);
+}
+function formatQuote(text) {
+	const shortened = text.length > longQuoteLength ? `${text.slice(0, quoteStartLength)}…${text.slice(-60)}` : text;
+	return JSON.stringify(shortened);
+}
+function indentContinuation(text, indent) {
+	return text.split("\n").join(`\n${indent}`);
+}
+//#endregion
+//#region src/cli/toRepositoryPath.ts
+/**
+* Turns a path the agent typed into the repo-relative POSIX path the server uses
+*
+* @param root the root's real path
+* @param absolutePath the path, already resolved against the working directory
+* @throws CliError when the path is outside the root
+*/
+function toRepositoryPath(root, absolutePath) {
+	const relativePath = path.relative(root, absolutePath);
+	if (relativePath === "" || relativePath.startsWith("..") || path.isAbsolute(relativePath)) throw new CliError(`${absolutePath} is not a file inside the repository at ${root}`, "Pass a path to a markdown file inside the repository.");
+	return relativePath.split(path.sep).join("/");
+}
+//#endregion
+//#region src/cli/readDocumentOption.ts
+/**
+* Reads a `--document <path>` option, which may be relative to the working directory
+*
+* @param root the root's real path
+* @param workingDirectory the directory the command runs in
+* @param value the option's value, if it was given
+* @returns the doc's repo-relative POSIX path, or null when the option was not given
+*/
+async function readDocumentOption(root, workingDirectory, value) {
+	return value === void 0 ? null : toRepositoryPath(root, path.resolve(await realpath(workingDirectory), value));
+}
+//#endregion
+//#region src/cli/commands/inboxCommand.ts
+async function inboxCommand(args, { cliPath, terminal }) {
+	const { values } = parseArgs({
+		args,
+		options: { document: { type: "string" } }
+	});
+	const root = await findRoot(terminal.workingDirectory);
+	const document = await readDocumentOption(root, terminal.workingDirectory, values.document);
+	const client = await connectToServer(root, cliPath);
+	terminal.stdout(formatInbox(await client.inbox(document)));
+	return 0;
+}
+//#endregion
+//#region skills/markdown-review/SKILL.md?raw
+var SKILL_default = "---\nname: markdown-review\ndescription: Hands markdown docs you wrote, such as plans, specs and design notes, to the user to review in their browser, then reads their comments back so you can edit the docs and answer each one. Use when the user asks you to have a doc reviewed, or when a doc you wrote needs their sign-off before you carry on.\n---\n\n# Markdown Review\n\nThe user reviews your markdown in a browser and comments on passages, blocks, whole docs or the review as a whole. You read the comments with the `markdown-review` command, edit the docs, and answer each comment.\n\nIf the `markdown-review` command is not found, install it with `npm install --global @krelborn/markdown-review`.\n\n## The review loop\n\n1. Run `markdown-review open <doc.md>`. It starts a review round and shows the doc in the user's browser.\n2. Run `markdown-review poll`. It waits until the user submits, then prints each comment: its thread ID, file, line range, the quoted text and the user's words.\n   - Give the shell command a timeout of at least 600000 ms. `poll` gives up after 540 seconds by default; run it again if it says there are no comments yet.\n   - In Claude Code, run it with `run_in_background` and `--timeout 7080`, and a Bash timeout of 7200000 ms. A submit still ends it at once.\n3. Edit the docs. Then answer every thread:\n   - `markdown-review resolve <id> \"<what changed>\"` when you have addressed it.\n   - `markdown-review reply <id> \"<question>\"` when you need the user's input.\n   - For a long message, put it in a file and pass `--file <path>`, or pass `--file -` and write it to standard input.\n4. Run `markdown-review poll` again for the next round.\n\n`markdown-review inbox` prints what `poll` would, without waiting, for picking comments up later.\n\n## Approval\n\nThe review ends when the user approves it, and `poll` and `inbox` then start with \"Review approved\". Address any comments that came with the approval, then carry on with your task. Do not run `poll` again for that review.\n\n## Good to know\n\n- A quote is the text as the browser shows it, not the markdown source. The line range is exact, so use it to find the passage.\n- If `poll` is stopped before the user submits, nothing is lost: run it again.\n- Every command ends with a `next_step` line that says what to do next. `markdown-review --help` lists the commands.\n- Run `markdown-review stop` to stop the review server when you have finished.\n";
+//#endregion
+//#region src/cli/commands/installSkillCommand.ts
+/**
+* Writes the skill that teaches agents the review workflow where Claude Code and OpenCode look for skills
+*/
+async function installSkillCommand(args, { terminal }) {
+	const { values } = parseArgs({
+		args,
+		options: { global: { type: "boolean" } }
+	});
+	const base = values.global === true ? terminal.env.HOME ?? os.homedir() : await findRoot(terminal.workingDirectory);
+	const skillPath = path.join(base, ".claude", "skills", "markdown-review", "SKILL.md");
+	const installed = await readTextFileOrNull(skillPath);
+	await mkdir(path.dirname(skillPath), { recursive: true });
+	await writeFile(skillPath, SKILL_default);
+	const outcome = installed === null ? "Installed" : installed === "---\nname: markdown-review\ndescription: Hands markdown docs you wrote, such as plans, specs and design notes, to the user to review in their browser, then reads their comments back so you can edit the docs and answer each one. Use when the user asks you to have a doc reviewed, or when a doc you wrote needs their sign-off before you carry on.\n---\n\n# Markdown Review\n\nThe user reviews your markdown in a browser and comments on passages, blocks, whole docs or the review as a whole. You read the comments with the `markdown-review` command, edit the docs, and answer each comment.\n\nIf the `markdown-review` command is not found, install it with `npm install --global @krelborn/markdown-review`.\n\n## The review loop\n\n1. Run `markdown-review open <doc.md>`. It starts a review round and shows the doc in the user's browser.\n2. Run `markdown-review poll`. It waits until the user submits, then prints each comment: its thread ID, file, line range, the quoted text and the user's words.\n   - Give the shell command a timeout of at least 600000 ms. `poll` gives up after 540 seconds by default; run it again if it says there are no comments yet.\n   - In Claude Code, run it with `run_in_background` and `--timeout 7080`, and a Bash timeout of 7200000 ms. A submit still ends it at once.\n3. Edit the docs. Then answer every thread:\n   - `markdown-review resolve <id> \"<what changed>\"` when you have addressed it.\n   - `markdown-review reply <id> \"<question>\"` when you need the user's input.\n   - For a long message, put it in a file and pass `--file <path>`, or pass `--file -` and write it to standard input.\n4. Run `markdown-review poll` again for the next round.\n\n`markdown-review inbox` prints what `poll` would, without waiting, for picking comments up later.\n\n## Approval\n\nThe review ends when the user approves it, and `poll` and `inbox` then start with \"Review approved\". Address any comments that came with the approval, then carry on with your task. Do not run `poll` again for that review.\n\n## Good to know\n\n- A quote is the text as the browser shows it, not the markdown source. The line range is exact, so use it to find the passage.\n- If `poll` is stopped before the user submits, nothing is lost: run it again.\n- Every command ends with a `next_step` line that says what to do next. `markdown-review --help` lists the commands.\n- Run `markdown-review stop` to stop the review server when you have finished.\n" ? "Reinstalled" : "Updated";
+	terminal.stdout(`${outcome} the markdown-review skill at ${skillPath}\n\nnext_step: The skill loads when an agent session starts. To start a review now, run \`markdown-review open <doc.md>\`.
+`);
+	return 0;
+}
+//#endregion
+//#region src/cli/commands/openCommand.ts
+async function openCommand(args, { cliPath, terminal }) {
+	const { positionals } = parseArgs({
+		allowPositionals: true,
+		args,
+		options: {}
+	});
+	if (positionals.length > 1) throw new CliError("open takes at most one path", "Run `markdown-review open [path]`.", 2);
+	const target = positionals[0];
+	const workingRoot = await findRoot(terminal.workingDirectory);
+	const { document, root } = target === void 0 ? {
+		document: null,
+		root: workingRoot
+	} : await locate(terminal.workingDirectory, target);
+	const { navigated, url } = await (await connectToServer(root, cliPath)).open(document);
+	const shown = navigated ? "Shown in the browser tab that was already open." : await openUrl(url, terminal.env);
+	const nextStep = root === workingRoot ? waitForCommentsStep : waitForCommentsInRootStep(root);
+	terminal.stdout(`Opened ${document ?? "the docs list"} for review: ${url}\n${shown}\n\nnext_step: ${nextStep}\n`);
+	return 0;
+}
+async function locate(workingDirectory, target) {
+	const absolutePath = path.resolve(workingDirectory, target);
+	const found = await stat(absolutePath).catch(() => null);
+	if (found === null || !found.isFile()) throw new CliError(`${target} is not a file`, "Check the path and run `markdown-review open <path>` again.");
+	const root = await findRoot(path.dirname(absolutePath), workingDirectory);
+	return {
+		document: toRepositoryPath(root, await realpath(absolutePath)),
+		root
+	};
+}
+async function openUrl(url, env) {
+	if (env.MARKDOWN_REVIEW_NO_BROWSER === "1") return "Not opened in a browser because MARKDOWN_REVIEW_NO_BROWSER is set; give the user the URL.";
+	try {
+		await openInBrowser(url);
+		return "Opened in the user's browser.";
+	} catch {
+		return "Could not open a browser; give the user the URL.";
+	}
+}
+//#endregion
+//#region src/cli/commands/pollCommand.ts
+var defaultTimeoutSeconds$1 = 540;
+var interruptedExitCodes = {
+	SIGINT: 130,
+	SIGTERM: 143
+};
+async function pollCommand(args, { cliPath, terminal }) {
+	const { values } = parseArgs({
+		args,
+		options: {
+			document: { type: "string" },
+			timeout: { type: "string" }
+		}
+	});
+	const timeoutSeconds = readTimeout(values.timeout);
+	const root = await findRoot(terminal.workingDirectory);
+	const document = await readDocumentOption(root, terminal.workingDirectory, values.document);
+	const client = await connectToServer(root, cliPath);
+	const abort = new AbortController();
+	let interruptedBy;
+	const onSignal = (signal) => {
+		interruptedBy = signal;
+		abort.abort();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	try {
+		terminal.stderr(`Waiting up to ${timeoutSeconds}s for review comments. If this is interrupted, run \`markdown-review poll\` again; nothing is lost.\n`);
+		const result = await client.poll(document, timeoutSeconds, abort.signal);
+		if (result.timedOut && result.threads.length === 0 && !result.review.approved) terminal.stdout(`No comments yet.\n\nnext_step: Run \`markdown-review poll\` again to keep waiting. ${pollTimeoutAdvice}\n`);
+		else terminal.stdout(formatInbox(result));
+		return 0;
+	} catch (error) {
+		if (interruptedBy !== void 0) {
+			terminal.stderr("Interrupted while waiting. Nothing was lost; run `markdown-review poll` again to keep waiting.\n");
+			return interruptedExitCodes[interruptedBy] ?? 1;
+		}
+		if (error instanceof ServerRequestError) throw error;
+		throw new CliError("The review server stopped while you were waiting", "Run `markdown-review poll` again; it starts the server again and nothing was lost.");
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+	}
+}
+function readTimeout(value) {
+	if (value === void 0) return defaultTimeoutSeconds$1;
+	if (!/^[0-9]+$/.test(value)) throw new CliError(`--timeout must be a whole number of seconds, not ${value}`, "Run `markdown-review poll --timeout 540`.", 2);
+	return Number(value);
+}
+//#endregion
+//#region src/server/runtime/createConsoleLogger.ts
+/**
+* Creates the server process's logger; the CLI points the process's output at `.markdown-review/server.log`
+*
+* @returns a logger that writes one timestamped line per entry
+*/
+function createConsoleLogger() {
+	const write = (level, message, error) => {
+		const detail = error === void 0 ? "" : ` ${error instanceof Error ? error.stack ?? error.message : String(error)}`;
+		process.stdout.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${level} ${message}${detail}\n`);
+	};
+	return {
+		error: (message, error) => write("error", message, error),
+		info: (message) => write("info", message),
+		warn: (message, error) => write("warn", message, error)
+	};
+}
+//#endregion
+//#region src/server/events/BrowserTabs.ts
+/**
+* The browser tabs connected to the server's event stream, in the order they connected
+*/
+var BrowserTabs = class {
+	tabs = [];
+	/**
+	* @returns a function that disconnects the tab
+	*/
+	connect(tab) {
+		this.tabs.push(tab);
+		return () => {
+			const index = this.tabs.indexOf(tab);
+			if (index !== -1) this.tabs.splice(index, 1);
+		};
+	}
+	/**
+	* Shows a page in the most recently connected tab
+	*
+	* @param url the page to show
+	* @returns false when no tab is connected
+	*/
+	navigateLatest(url) {
+		const latest = this.tabs.at(-1);
+		latest?.navigate(url);
+		return latest !== void 0;
+	}
+};
+//#endregion
+//#region src/server/events/ServerEvents.ts
+/**
+* Carries changes between the parts of the server: a submit wakes waiting polls, and the rest reach connected tabs
+*/
+var ServerEvents = class {
+	listeners = /* @__PURE__ */ new Set();
+	publish(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+	/**
+	* @returns a function that stops the listener receiving events
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+};
+//#endregion
+//#region src/server/files/writeJsonAtomically.ts
+/**
+* Writes a value as formatted JSON so readers see either the old file or the new one, never half of it
+*
+* @param filePath the file to write; missing parent directories are created
+* @param value the value to serialise
+* @param mode the file's permissions, e.g. 0o600 to keep other users out; the platform default when omitted
+*/
+async function writeJsonAtomically(filePath, value, mode) {
+	const contents = `${JSON.stringify(value, null, 2)}\n`;
+	await mkdir(path.dirname(filePath), { recursive: true });
+	const temporaryPath = `${filePath}.${randomUUID()}.tmp`;
+	await writeFile(temporaryPath, contents, {
+		encoding: "utf8",
+		mode
+	});
+	await rename(temporaryPath, filePath);
+}
+//#endregion
+//#region src/server/store/StoreError.ts
+/**
+* A store operation that cannot be carried out; `reason` says why
+*/
+var StoreError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "StoreError";
+		this.reason = reason;
+	}
+};
+//#endregion
+//#region src/shared/api/apiRequestSchemas.ts
+var agentOpenRequestSchema = z.strictObject({ path: documentPathSchema.optional() });
+var messageRequestSchema = z.strictObject({ body: messageBodySchema });
+var resolveRequestSchema = z.strictObject({ body: messageBodySchema.nullable() });
+var submitRequestSchema = z.strictObject({ verdict: z.enum(["request-changes", "approve"]) });
+//#endregion
+//#region src/server/files/resolveRepositoryPath.ts
+/**
+* Finds a file in the repo from its repo-relative path
+*
+* @param root the repo root
+* @param relativePath a repo-relative POSIX path, e.g. "docs/plan.md"
+* @returns the file's real path when it is inside the repo; "outside" when it, or a symlink on the way, leads out of
+*   the repo; "private" when it, or a symlink on the way, leads into `.markdown-review/`, which holds the server's
+*   token; "missing" when nothing exists there; "invalid" when the path is not repo-relative
+*/
+async function resolveRepositoryPath(root, relativePath) {
+	if (!isRepositoryRelativePath(relativePath)) return { kind: "invalid" };
+	const joinedPath = path.join(root, ...relativePath.split("/"));
+	if (isInDirectory(joinedPath, storeDirectory(root))) return { kind: "private" };
+	let absolutePath;
+	try {
+		absolutePath = await realpath(joinedPath);
+	} catch (error) {
+		if (isFileNotFound(error) || isNotDirectory(error)) return { kind: "missing" };
+		throw error;
+	}
+	const realRoot = await realpath(root);
+	if (!absolutePath.startsWith(realRoot + path.sep)) return { kind: "outside" };
+	return isInDirectory(absolutePath, storeDirectory(realRoot)) ? { kind: "private" } : {
+		absolutePath,
+		kind: "inside"
+	};
+}
+function isInDirectory(filePath, directory) {
+	return filePath === directory || filePath.startsWith(directory + path.sep);
+}
+function isNotDirectory(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOTDIR";
+}
+//#endregion
+//#region src/server/store/parseStoreInput.ts
+/**
+* Checks a value before the store acts on it or writes it
+*
+* @param schema the shape the value must have
+* @param value the value
+* @param description what the value is, for the error message, e.g. "The reply"
+* @returns the validated value
+* @throws StoreError "invalid-input" when the value does not have that shape
+*/
+function parseStoreInput(schema, value, description) {
+	const result = schema.safeParse(value);
+	if (!result.success) throw new StoreError("invalid-input", `${description} is not valid:\n${z.prettifyError(result.error)}`);
+	return result.data;
+}
+//#endregion
+//#region src/server/http/HttpError.ts
+/**
+* A request the server refuses, with the HTTP status and a stable `reason` the CLI and the browser can act on
+*/
+var HttpError = class extends Error {
+	reason;
+	status;
+	constructor(status, reason, message) {
+		super(message);
+		this.name = "HttpError";
+		this.reason = reason;
+		this.status = status;
+	}
+};
+//#endregion
+//#region src/server/http/requestInputs.ts
+/**
+* Reads and validates a JSON request body
+*
+* @throws StoreError "invalid-input" when the body is not JSON or does not have the schema's shape
+*/
+async function readJsonBody(context, schema) {
+	let body;
+	try {
+		body = await context.req.json();
+	} catch {
+		body = void 0;
+	}
+	return parseStoreInput(schema, body, "The request body");
+}
+/**
+* Reads the `:id` route parameter
+*
+* @throws HttpError 400 when it is not a positive whole number
+*/
+function readThreadId(context) {
+	const id = context.req.param("id") ?? "";
+	if (!/^[1-9][0-9]*$/.test(id)) throw new HttpError(400, "invalid-input", `"${id}" is not a thread ID`);
+	return Number(id);
+}
+/**
+* Checks that a doc path from a request stays inside the repo
+*
+* @param root the repo root
+* @param document a repo-relative POSIX path
+* @param allowMissing whether a doc that no longer exists is acceptable, as it is when reading its threads
+* @throws HttpError 400 for a path that is not repo-relative, 403 for one that leads out of the repo or into the
+*   review store, and 404 for a missing doc unless `allowMissing` is set
+*/
+async function checkDocumentPath(root, document, allowMissing) {
+	switch ((await resolveRepositoryPath(root, document)).kind) {
+		case "invalid": throw new HttpError(400, "invalid-input", `${document} is not a repo-relative path`);
+		case "outside": throw new HttpError(403, "outside-root", `${document} leads outside the repo`);
+		case "private": throw new HttpError(403, "private-file", `${document} is in the review store`);
+		case "missing":
+			if (!allowMissing) throw new HttpError(404, "missing-document", `${document} does not exist`);
+			return;
+		case "inside": return;
+	}
+}
+//#endregion
+//#region src/server/http/agentRoutes.ts
+var shutdownDelayMilliseconds = 100;
+function registerAgentRoutes(app, dependencies) {
+	const { events, port, recentDocuments, root, shutdown, store, tabs, watchDocument } = dependencies;
+	const afterAgentAction = async (thread) => {
+		events.publish({ type: "threads-changed" });
+		return {
+			inbox: await store.readInbox(null),
+			thread
+		};
+	};
+	app.post("/api/shutdown", (context) => {
+		setTimeout(shutdown, shutdownDelayMilliseconds);
+		return context.json({ stopping: true });
+	});
+	app.post("/api/agent/open", async (context) => {
+		const { path } = await readJsonBody(context, agentOpenRequestSchema);
+		if (path !== void 0) {
+			await checkDocumentPath(root, path, false);
+			recentDocuments.add(path);
+			watchDocument(path);
+		}
+		const review = await store.requestReview();
+		events.publish({ type: "threads-changed" });
+		const pagePath = path === void 0 ? "" : `document/${path.split("/").map(encodeURIComponent).join("/")}`;
+		const url = `http://127.0.0.1:${port()}/${pagePath}`;
+		const response = {
+			navigated: tabs.navigateLatest(url),
+			review,
+			url
+		};
+		return context.json(response);
+	});
+	app.get("/api/inbox", async (context) => {
+		const document = context.req.query("document");
+		if (document !== void 0) await checkDocumentPath(root, document, true);
+		return context.json(await store.readInbox(document ?? null));
+	});
+	app.post("/api/agent/threads/:id/reply", async (context) => {
+		const { body } = await readJsonBody(context, messageRequestSchema);
+		return context.json(await afterAgentAction(await store.replyAsAgent(readThreadId(context), body)));
+	});
+	app.post("/api/agent/threads/:id/resolve", async (context) => {
+		const { body } = await readJsonBody(context, resolveRequestSchema);
+		return context.json(await afterAgentAction(await store.resolveAsAgent(readThreadId(context), body)));
+	});
+}
+//#endregion
+//#region src/shared/review/newThreadSchema.ts
+var newPassageAnchorSchema = z.strictObject({
+	document: documentPathSchema,
+	endOffset: z.int().nonnegative(),
+	kind: z.literal("passage"),
+	prefix: z.string().max(32),
+	quote: z.string().min(1),
+	startOffset: z.int().nonnegative(),
+	suffix: z.string().max(32)
+}).refine((anchor) => anchor.endOffset - anchor.startOffset === anchor.quote.length, { message: "must span exactly its quote" });
+var newThreadSchema = z.strictObject({
+	anchor: z.discriminatedUnion("kind", [
+		reviewAnchorSchema,
+		documentAnchorSchema,
+		newPassageAnchorSchema
+	]),
+	body: messageBodySchema,
+	renderedHash: z.string().optional()
+});
+//#endregion
+//#region src/server/store/hashSource.ts
+/**
+* Fingerprints a doc's source so the store can tell when anchors were computed against an older version
+*
+* @param source the markdown source
+* @returns the SHA-256 of the source, as 64 lowercase hex digits
+*/
+function hashSource(source) {
+	return createHash("sha256").update(source, "utf8").digest("hex");
+}
+//#endregion
+//#region src/server/http/browserRoutes.ts
+function registerBrowserRoutes(app, dependencies) {
+	const { events, recentDocuments, root, store, watchDocument } = dependencies;
+	const threadsChanged = () => events.publish({ type: "threads-changed" });
+	app.get("/api/documents", async (context) => {
+		const { problems, threads } = await store.readThreads(null);
+		const response = {
+			documents: countByDocument(threads),
+			problems,
+			recent: recentDocuments.list()
+		};
+		return context.json(response);
+	});
+	app.get("/api/document", async (context) => {
+		const document = context.req.query("path") ?? "";
+		await checkDocumentPath(root, document, false);
+		const source = await readFile(path.join(root, ...document.split("/")), "utf8");
+		recentDocuments.add(document);
+		watchDocument(document);
+		const response = {
+			hash: hashSource(source),
+			path: document,
+			source
+		};
+		return context.json(response);
+	});
+	app.get("/api/threads", async (context) => {
+		const document = context.req.query("document");
+		if (document === void 0 && context.req.query("all") !== "1") throw new HttpError(400, "invalid-input", "Pass ?document=<path> or ?all=1");
+		if (document !== void 0) {
+			await checkDocumentPath(root, document, true);
+			watchDocument(document);
+		}
+		return context.json(await store.readThreads(document ?? null));
+	});
+	app.post("/api/threads", async (context) => {
+		const newThread = await readJsonBody(context, newThreadSchema);
+		if (newThread.anchor.kind !== "review") {
+			await checkDocumentPath(root, newThread.anchor.document, false);
+			watchDocument(newThread.anchor.document);
+		}
+		const thread = await store.createDraftThread(newThread);
+		threadsChanged();
+		return context.json({ thread }, 201);
+	});
+	app.put("/api/threads/:id/draft", async (context) => {
+		const { body } = await readJsonBody(context, messageRequestSchema);
+		const thread = await store.writeDraft(readThreadId(context), body);
+		threadsChanged();
+		return context.json({ thread });
+	});
+	app.delete("/api/threads/:id/draft", async (context) => {
+		const thread = await store.deleteDraft(readThreadId(context));
+		threadsChanged();
+		return context.json({ thread });
+	});
+	app.post("/api/threads/:id/resolve", async (context) => {
+		const thread = await store.resolveAsUser(readThreadId(context));
+		threadsChanged();
+		return context.json({ thread });
+	});
+	app.post("/api/submit", async (context) => {
+		const { verdict } = await readJsonBody(context, submitRequestSchema);
+		const result = await store.submit(verdict);
+		events.publish({ type: "submitted" });
+		threadsChanged();
+		return context.json(result);
+	});
+}
+function countByDocument(threads) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const thread of threads) {
+		if (thread.anchor.kind === "review") continue;
+		const count = counts.get(thread.anchor.document) ?? {
+			draftCount: 0,
+			openCount: 0
+		};
+		counts.set(thread.anchor.document, {
+			draftCount: count.draftCount + (thread.draft === void 0 ? 0 : 1),
+			openCount: count.openCount + (thread.status === "open" ? 1 : 0)
+		});
+	}
+	return [...counts].filter(([, count]) => count.draftCount + count.openCount > 0).map(([document, count]) => ({
+		document,
+		...count
+	})).sort((left, right) => left.document.localeCompare(right.document));
+}
+//#endregion
+//#region src/server/http/eventRoutes.ts
+function registerEventRoutes(app, { activity, events, logger, tabs }) {
+	app.get("/api/events", (context) => streamSSE(context, async (output) => {
+		let writes = Promise.resolve();
+		const send = (event, data) => {
+			writes = writes.then(() => output.writeSSE({
+				data: JSON.stringify(data),
+				event
+			})).catch((error) => logger.warn("Could not write to a browser's event stream", error));
+		};
+		const endBrowser = activity.beginBrowser();
+		const unsubscribe = events.subscribe((event) => {
+			if (event.type !== "submitted") {
+				const { type, ...data } = event;
+				send(type, data);
+			}
+		});
+		const disconnect = tabs.connect({ navigate: (url) => send("navigate", { url }) });
+		send("presence", { agentWaiting: activity.agentWaiting });
+		await new Promise((resolve) => output.onAbort(resolve));
+		unsubscribe();
+		disconnect();
+		endBrowser();
+	}));
+}
+//#endregion
+//#region src/server/http/contentTypeFor.ts
+var contentTypes = {
+	".gif": "image/gif",
+	".html": "text/html; charset=utf-8",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".json": "application/json",
+	".md": "text/markdown; charset=utf-8",
+	".pdf": "application/pdf",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".txt": "text/plain; charset=utf-8",
+	".webp": "image/webp"
+};
+/**
+* Picks the Content-Type for a repo file from its extension
+*
+* @param filePath the file's path
+* @returns the media type, or application/octet-stream for an extension it does not know
+*/
+function contentTypeFor(filePath) {
+	return contentTypes[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+//#endregion
+//#region src/server/http/fileRoutes.ts
+function registerFileRoutes(app, { root }) {
+	app.get("/files/*", async (context) => {
+		const relativePath = decodeURIComponent(context.req.path.slice(7));
+		const resolved = await resolveRepositoryPath(root, relativePath);
+		if (resolved.kind === "invalid" || resolved.kind === "outside") throw new HttpError(403, "outside-root", `${relativePath} is not a file in the repo`);
+		if (resolved.kind === "private") throw new HttpError(403, "private-file", `${relativePath} is in the review store`);
+		if (resolved.kind === "missing" || !(await stat(resolved.absolutePath)).isFile()) throw new HttpError(404, "missing-file", `${relativePath} does not exist`);
+		const contents = await readFile(resolved.absolutePath);
+		return context.body(new Uint8Array(contents), 200, {
+			"Content-Security-Policy": "sandbox",
+			"Content-Type": contentTypeFor(relativePath),
+			"X-Content-Type-Options": "nosniff"
+		});
+	});
+}
+//#endregion
+//#region src/server/http/healthRoutes.ts
+function registerHealthRoutes(app, { root, version }) {
+	app.get("/api/health", (context) => {
+		const health = {
+			name: "markdown-review",
+			pid: process.pid,
+			protocol: 1,
+			root,
+			version
+		};
+		return context.json(health);
+	});
+}
+//#endregion
+//#region src/server/http/waitForInbox.ts
+/**
+* Waits until the review is approved or a thread needs the agent
+*
+* @returns the inbox as soon as it has something for the agent, or as it stands when the time runs out or the
+*   request is aborted, with `timedOut` set
+*/
+async function waitForInbox({ document, events, signal, store, timeoutMilliseconds }) {
+	const deadline = Date.now() + timeoutMilliseconds;
+	for (;;) {
+		const nextSubmit = waitForSubmit(events, deadline - Date.now(), signal);
+		const inbox = await store.readInbox(document);
+		if (inbox.review.approved || inbox.threads.length > 0) {
+			nextSubmit.cancel();
+			return {
+				...inbox,
+				timedOut: false
+			};
+		}
+		if (await nextSubmit.outcome !== "submitted") return {
+			...inbox,
+			timedOut: true
+		};
+	}
+}
+/**
+* Starts listening for the next submit straight away, so one that happens while the inbox is being read is not missed
+*/
+function waitForSubmit(events, timeoutMilliseconds, signal) {
+	let finish = () => {};
+	const outcome = new Promise((resolve) => {
+		finish = resolve;
+	});
+	const timer = setTimeout(() => finish("timed-out"), Math.max(0, timeoutMilliseconds));
+	const onAbort = () => finish("aborted");
+	signal.addEventListener("abort", onAbort);
+	const unsubscribe = events.subscribe((event) => {
+		if (event.type === "submitted") finish("submitted");
+	});
+	const cancel = () => {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+		unsubscribe();
+	};
+	if (signal.aborted) finish("aborted");
+	outcome.then(cancel);
+	return {
+		cancel,
+		outcome
+	};
+}
+//#endregion
+//#region src/server/http/pollRoutes.ts
+var defaultTimeoutSeconds = 540;
+var maximumTimeoutSeconds = 86400;
+function registerPollRoutes(app, dependencies) {
+	const { activity, events, logger, pollKeepAliveMilliseconds, root, store } = dependencies;
+	app.get("/api/poll", async (context) => {
+		const document = context.req.query("document") ?? null;
+		if (document !== null) await checkDocumentPath(root, document, true);
+		const timeoutMilliseconds = readTimeoutSeconds(context.req.query("timeout")) * 1e3;
+		context.header("Content-Type", "application/json");
+		return stream(context, async (output) => {
+			const abort = new AbortController();
+			output.onAbort(() => abort.abort());
+			const endPoll = activity.beginPoll();
+			const keepAlive = setInterval(() => {
+				output.write(" ").catch(() => abort.abort());
+			}, pollKeepAliveMilliseconds);
+			try {
+				const result = await waitForInbox({
+					document,
+					events,
+					signal: abort.signal,
+					store,
+					timeoutMilliseconds
+				});
+				if (!abort.signal.aborted) await output.write(JSON.stringify(result));
+			} catch (error) {
+				logger.error("A poll failed", error);
+				await output.write(JSON.stringify({ error: {
+					message: "The poll failed; see .markdown-review/server.log",
+					reason: "internal"
+				} }));
+			} finally {
+				clearInterval(keepAlive);
+				endPoll();
+			}
+		});
+	});
+}
+function readTimeoutSeconds(value) {
+	if (value === void 0) return defaultTimeoutSeconds;
+	const seconds = Number(value);
+	if (!Number.isInteger(seconds) || seconds < 0 || seconds > maximumTimeoutSeconds) throw new HttpError(400, "invalid-input", `The timeout must be a whole number of seconds up to ${maximumTimeoutSeconds}`);
+	return seconds;
+}
+//#endregion
+//#region src/server/http/securityMiddleware.ts
+/**
+* Refuses requests whose Host header does not name this server, which blocks DNS rebinding
+*
+* @param port the port the server listens on
+*/
+function requireLocalHost(port) {
+	return async (context, next) => {
+		if (![`127.0.0.1:${port()}`, `localhost:${port()}`].includes(context.req.header("host") ?? "")) throw new HttpError(403, "forbidden", "The Host header does not name this server");
+		await next();
+	};
+}
+/**
+* Refuses requests a browser sends from a page on another site, so such a page can neither read the review nor connect
+* to the event stream as if it were a review tab
+*
+* @param port the port the server listens on
+*/
+function refuseOtherOrigins(port) {
+	return async (context, next) => {
+		const origin = context.req.header("origin");
+		if (origin !== void 0 && !ownOrigins(port()).includes(origin)) throw new HttpError(403, "forbidden", "Requests must come from this server's own pages");
+		await next();
+	};
+}
+/**
+* Lets only the CLI through: the request must carry the server's token and no Origin header, which browsers add
+*
+* @param token the secret from `server.json`
+*/
+function requireAgentToken(token) {
+	return async (context, next) => {
+		if (context.req.header("origin") !== void 0) throw new HttpError(403, "forbidden", "Agent routes do not accept requests from web pages");
+		if (!isExpectedToken(context.req.header("authorization"), token)) throw new HttpError(401, "unauthorized", "Agent routes need the token from .markdown-review/server.json");
+		await next();
+	};
+}
+/**
+* Lets changes through only from this server's own pages, sent as JSON, which an HTML form on another page cannot do
+*
+* @param port the port the server listens on
+*/
+function requireBrowserOrigin(port) {
+	return async (context, next) => {
+		if (context.req.method === "GET" || context.req.method === "HEAD") {
+			await next();
+			return;
+		}
+		if (!ownOrigins(port()).includes(context.req.header("origin") ?? "")) throw new HttpError(403, "forbidden", "Changes must come from this server's own pages");
+		if (!(context.req.header("content-type") ?? "").startsWith("application/json")) throw new HttpError(415, "unsupported-media-type", "Changes must be sent as application/json");
+		await next();
+	};
+}
+function ownOrigins(port) {
+	return [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
+}
+function isExpectedToken(authorization, token) {
+	const expected = Buffer.from(`Bearer ${token}`);
+	const actual = Buffer.from(authorization ?? "");
+	return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+//#endregion
+//#region src/server/http/shellRoutes.ts
+var assetContentTypes = {
+	".css": "text/css; charset=utf-8",
+	".js": "text/javascript; charset=utf-8"
+};
+var contentSecurityPolicy = "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'";
+function registerShellRoutes(app, { webDirectory }) {
+	const serveShell = async (context) => {
+		const html = await readTextFileOrNull(path.join(webDirectory, "index.html"));
+		if (html === null) throw new HttpError(500, "missing-web-app", "This build of markdown-review has no web app");
+		return context.html(html, 200, { "Content-Security-Policy": contentSecurityPolicy });
+	};
+	app.get("/", serveShell);
+	app.get("/document/*", serveShell);
+	app.get("/assets/*", async (context) => {
+		const name = context.req.path.slice(8);
+		if (!isRepositoryRelativePath(name)) throw new HttpError(404, "missing-file", `${name} is not an asset`);
+		let contents;
+		try {
+			contents = await readFile(path.join(webDirectory, "assets", ...name.split("/")));
+		} catch (error) {
+			if (isFileNotFound(error)) throw new HttpError(404, "missing-file", `${name} is not an asset`);
+			throw error;
+		}
+		return context.body(new Uint8Array(contents), 200, {
+			"Content-Type": assetContentTypes[path.extname(name)] ?? "application/octet-stream",
+			"X-Content-Type-Options": "nosniff"
+		});
+	});
+}
+//#endregion
+//#region src/server/http/createApp.ts
+var statusForStoreError = {
+	"invalid-file": 500,
+	"invalid-input": 400,
+	"invalid-state": 409,
+	"missing-document": 404,
+	"unknown-thread": 404
+};
+/**
+* Builds the server's HTTP app: the agent's API, the browser's API, the event stream, repo files and the app shell
+*
+* @param dependencies the store and the server's shared state
+* @returns the app, ready to be served on 127.0.0.1
+*/
+function createApp(dependencies) {
+	const { activity, logger, port, token } = dependencies;
+	const app = new Hono();
+	app.use("*", requireLocalHost(port));
+	app.use("*", refuseOtherOrigins(port));
+	app.use("*", async (_context, next) => {
+		activity.touch();
+		await next();
+	});
+	for (const agentPath of [
+		"/api/agent/*",
+		"/api/inbox",
+		"/api/poll",
+		"/api/shutdown"
+	]) app.use(agentPath, requireAgentToken(token));
+	for (const browserPath of [
+		"/api/threads",
+		"/api/threads/*",
+		"/api/submit"
+	]) app.use(browserPath, requireBrowserOrigin(port));
+	app.onError((error, context) => {
+		if (error instanceof HttpError) return context.json({ error: {
+			message: error.message,
+			reason: error.reason
+		} }, error.status);
+		if (error instanceof StoreError) return context.json({ error: {
+			message: error.message,
+			reason: error.reason
+		} }, statusForStoreError[error.reason]);
+		logger.error(`${context.req.method} ${context.req.path} failed`, error);
+		return context.json({ error: {
+			message: "The server failed to handle the request; see .markdown-review/server.log",
+			reason: "internal"
+		} }, 500);
+	});
+	registerHealthRoutes(app, dependencies);
+	registerAgentRoutes(app, dependencies);
+	registerPollRoutes(app, dependencies);
+	registerBrowserRoutes(app, dependencies);
+	registerEventRoutes(app, dependencies);
+	registerFileRoutes(app, dependencies);
+	registerShellRoutes(app, dependencies);
+	return app;
+}
+//#endregion
+//#region src/server/http/RecentDocuments.ts
+var recentLimit = 10;
+/**
+* The docs most recently opened by the agent or shown in a browser, newest first
+*/
+var RecentDocuments = class {
+	documents = [];
+	add(document) {
+		this.documents = [document, ...this.documents.filter((existing) => existing !== document)].slice(0, recentLimit);
+	}
+	list() {
+		return [...this.documents];
+	}
+};
+//#endregion
+//#region src/shared/markdown/fenceLanguage.ts
+/**
+* Reads the language of a fenced code block from its info string
+*
+* @param info the text after the opening fence, e.g. "ts title=example"
+* @returns the first word of the info string, or an empty string when there is none
+*/
+function fenceLanguage(info) {
+	return info.trim().split(/\s+/)[0] ?? "";
+}
+//#endregion
+//#region src/shared/markdown/findLeafBlocks.ts
+var leafBlockKinds = {
+	code_block: "codeBlock",
+	fence: "fence",
+	heading_open: "inline",
+	html_block: "htmlBlock",
+	paragraph_open: "inline",
+	tr_open: "tableRow"
+};
+/**
+* Finds the leaf blocks of a parsed doc
+*
+* @param tokens the token stream markdown-it parsed from `source`
+* @param source the markdown source
+* @returns the leaf blocks in document order
+*/
+function findLeafBlocks(tokens, source) {
+	const sourceLines = source.split(/\r\n?|\n/);
+	const leafBlocks = [];
+	tokens.forEach((token, tokenIndex) => {
+		const kind = leafBlockKinds[token.type];
+		if (kind === void 0 || token.map === null) return;
+		const [lineBegin, lineEnd] = token.map;
+		leafBlocks.push({
+			endLine: lastLineWithText(sourceLines, lineBegin, lineEnd),
+			kind,
+			startLine: lineBegin + 1,
+			token,
+			tokenIndex
+		});
+	});
+	return leafBlocks;
+}
+function lastLineWithText(sourceLines, lineBegin, lineEnd) {
+	let endLine = lineEnd;
+	while (endLine > lineBegin + 1 && (sourceLines[endLine - 1] ?? "").trim() === "") endLine -= 1;
+	return endLine;
+}
+//#endregion
+//#region src/shared/markdown/tokenAt.ts
+/**
+* Reads a token that markdown-it guarantees is present, such as the token a render rule was called for
+*
+* @param tokens the token stream
+* @param index the token's position in the stream
+* @returns the token
+* @throws RangeError when no token is at that position
+*/
+function tokenAt(tokens, index) {
+	const token = tokens[index];
+	if (token === void 0) throw new RangeError(`No markdown token at index ${index} of ${tokens.length}`);
+	return token;
+}
+//#endregion
+//#region src/shared/markdown/withoutFinalNewline.ts
+/**
+* Removes one trailing newline, as markdown-it leaves on the content of code and HTML blocks
+*
+* @param content the block content
+* @returns the content without its final newline
+*/
+function withoutFinalNewline(content) {
+	return content.endsWith("\n") ? content.slice(0, -1) : content;
+}
+//#endregion
+//#region src/shared/markdown/createMarkdownIt.ts
+/**
+* Creates the markdown-it instance the server and the browser share, so both find the same blocks
+*
+* @param options how rendering highlights fenced code; parsing does not use it
+* @returns an instance whose rendered leaf block elements carry `data-md-block`, `data-md-start` and `data-md-end`
+*/
+function createMarkdownIt({ highlight } = {}) {
+	const markdown = new markdownIt({ html: true }).use(tasklist);
+	const escapeHtml = markdown.utils.escapeHtml;
+	const renderFence = (tokens, index, _options, _environment, renderer) => {
+		const token = tokenAt(tokens, index);
+		const code = withoutFinalNewline(token.content);
+		const language = fenceLanguage(token.info);
+		const languageClass = language === "" ? "" : ` class="language-${escapeHtml(language)}"`;
+		const highlighted = highlight?.(code, language) ?? `<pre><code${languageClass}>${escapeHtml(code)}</code></pre>`;
+		return `<div${renderer.renderAttrs(token)}>${highlighted}</div>\n`;
+	};
+	const renderCodeBlock = (tokens, index, _options, _environment, renderer) => {
+		const token = tokenAt(tokens, index);
+		return `<div${renderer.renderAttrs(token)}><pre><code>${escapeHtml(withoutFinalNewline(token.content))}</code></pre></div>\n`;
+	};
+	markdown.core.ruler.push("tag_leaf_blocks", tagLeafBlocks);
+	markdown.renderer.rules.paragraph_open = renderParagraphOpen;
+	markdown.renderer.rules.paragraph_close = renderParagraphClose;
+	markdown.renderer.rules.fence = renderFence;
+	markdown.renderer.rules.code_block = renderCodeBlock;
+	markdown.renderer.rules.html_block = renderHtmlBlock;
+	return markdown;
+}
+function tagLeafBlocks(state) {
+	findLeafBlocks(state.tokens, state.src).forEach(({ endLine, startLine, token }, blockIndex) => {
+		token.attrSet("data-md-block", blockIndex);
+		token.attrSet("data-md-start", startLine);
+		token.attrSet("data-md-end", endLine);
+	});
+}
+var renderParagraphOpen = (tokens, index, options, _environment, renderer) => {
+	const token = tokenAt(tokens, index);
+	return token.hidden ? `<span${renderer.renderAttrs(token)}>` : renderer.renderToken(tokens, index, options);
+};
+var renderParagraphClose = (tokens, index, options, _environment, renderer) => tokenAt(tokens, index).hidden ? "</span>" : renderer.renderToken(tokens, index, options);
+var renderHtmlBlock = (tokens, index, _options, _environment, renderer) => {
+	const token = tokenAt(tokens, index);
+	return `<div${renderer.renderAttrs(token)}>${token.content}</div>\n`;
+};
+//#endregion
+//#region src/shared/markdown/hasStructuralHtml.ts
+var phrasingTagNames = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"br",
+	"cite",
+	"code",
+	"data",
+	"del",
+	"dfn",
+	"em",
+	"i",
+	"img",
+	"ins",
+	"kbd",
+	"mark",
+	"q",
+	"s",
+	"samp",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u",
+	"var",
+	"wbr"
+]);
+/**
+* Tells whether a paragraph or heading holds inline HTML that the browser may move out of the block, or that the
+* sanitizer may remove with its content, so the rendered text can differ from the canonical text
+*
+* @param children the children of the block's inline token
+* @returns true when an inline HTML tag is not one of the phrasing elements such as `span`, `b` or `a`
+*/
+function hasStructuralHtml(children) {
+	return children.some((child) => {
+		if (child.type !== "html_inline") return false;
+		const tagName = /^<\/?([a-z][a-z0-9-]*)/i.exec(child.content)?.[1];
+		return tagName !== void 0 && !phrasingTagNames.has(tagName.toLowerCase());
+	});
+}
+//#endregion
+//#region src/shared/markdown/inlineText.ts
+var textTokenTypes = /* @__PURE__ */ new Set([
+	"text",
+	"text_special",
+	"code_inline"
+]);
+var lineBreakTokenTypes = /* @__PURE__ */ new Set(["softbreak", "hardbreak"]);
+/**
+* Reads the canonical text of a paragraph, heading or table cell
+*
+* @param children the children of the block's inline token
+* @returns the text as the browser shows it, with each line break as "\n"; images and HTML tags contribute nothing
+*/
+function inlineText(children) {
+	let text = "";
+	const lineStartOffsets = [];
+	for (const child of children) if (textTokenTypes.has(child.type)) text += child.content;
+	else if (lineBreakTokenTypes.has(child.type)) {
+		text += "\n";
+		lineStartOffsets.push(text.length);
+	}
+	return {
+		lineStartOffsets,
+		text
+	};
+}
+//#endregion
+//#region src/shared/markdown/parseBlocks.ts
+var markdown = createMarkdownIt();
+/**
+* Splits a doc into the leaf blocks comments anchor to
+*
+* @param source the markdown source
+* @returns the leaf blocks in document order, each with its canonical text; a block with no visible text, such as an
+*   image on its own, takes whole-block comments only and its text is its source
+*/
+function parseBlocks(source) {
+	const tokens = markdown.parse(source, {});
+	const sourceLines = source.split(/\r\n?|\n/);
+	return findLeafBlocks(tokens, source).map((leafBlock) => {
+		const block = toMarkdownBlock(tokens, leafBlock);
+		return block.text === "" ? toSourceTextBlock(block, sourceLines) : block;
+	});
+}
+function toSourceTextBlock({ endLine, startLine }, sourceLines) {
+	const text = sourceLines.slice(startLine - 1, endLine).join("\n");
+	return {
+		endLine,
+		exactLines: true,
+		lineOffsets: codeLineOffsets(text, startLine, endLine),
+		startLine,
+		text,
+		wholeBlockOnly: true
+	};
+}
+function toMarkdownBlock(tokens, leafBlock) {
+	const { endLine, kind, startLine, token, tokenIndex } = leafBlock;
+	switch (kind) {
+		case "inline": {
+			const children = tokenAt(tokens, tokenIndex + 1).children ?? [];
+			const { lineStartOffsets, text } = inlineText(children);
+			const lineOffsets = [0, ...lineStartOffsets].map((offset, index) => ({
+				line: startLine + index,
+				offset
+			}));
+			const isSetextHeading = token.markup === "=" || token.markup === "-";
+			const textLineCount = endLine - startLine + (isSetextHeading ? 0 : 1);
+			return {
+				endLine,
+				exactLines: lineOffsets.length === textLineCount,
+				lineOffsets,
+				startLine,
+				text,
+				wholeBlockOnly: hasStructuralHtml(children)
+			};
+		}
+		case "tableRow": {
+			const text = tableRowCells(tokens, tokenIndex).join("	");
+			return {
+				endLine,
+				exactLines: true,
+				lineOffsets: [{
+					line: startLine,
+					offset: 0
+				}],
+				startLine,
+				text,
+				wholeBlockOnly: false
+			};
+		}
+		case "fence": {
+			const text = withoutFinalNewline(token.content);
+			const wholeBlockOnly = fenceLanguage(token.info) === "mermaid";
+			return {
+				endLine,
+				exactLines: true,
+				lineOffsets: codeLineOffsets(text, startLine + 1, endLine),
+				startLine,
+				text,
+				wholeBlockOnly
+			};
+		}
+		case "codeBlock":
+		case "htmlBlock": {
+			const text = withoutFinalNewline(token.content);
+			const wholeBlockOnly = kind === "htmlBlock";
+			return {
+				endLine,
+				exactLines: true,
+				lineOffsets: codeLineOffsets(text, startLine, endLine),
+				startLine,
+				text,
+				wholeBlockOnly
+			};
+		}
+	}
+}
+function tableRowCells(tokens, rowTokenIndex) {
+	const cells = [];
+	for (let index = rowTokenIndex + 1; index < tokens.length; index++) {
+		const token = tokenAt(tokens, index);
+		if (token.type === "tr_close") break;
+		if (token.type === "inline") cells.push(inlineText(token.children ?? []).text);
+	}
+	return cells;
+}
+function codeLineOffsets(text, firstLine, lastLine) {
+	if (text === "") return [];
+	const lineOffsets = [{
+		line: firstLine,
+		offset: 0
+	}];
+	for (let offset = text.indexOf("\n"); offset !== -1; offset = text.indexOf("\n", offset + 1)) lineOffsets.push({
+		line: firstLine + lineOffsets.length,
+		offset: offset + 1
+	});
+	return lineOffsets.filter(({ line }) => line <= lastLine);
+}
+//#endregion
+//#region src/shared/markdown/createDocumentText.ts
+/**
+* Builds the canonical text of a doc
+*
+* @param source the markdown source
+* @returns the doc's blocks, their joined text and where each block starts in it
+*/
+function createDocumentText(source) {
+	const blocks = parseBlocks(source);
+	const blockStartOffsets = [];
+	let offset = 0;
+	for (const block of blocks) {
+		blockStartOffsets.push(offset);
+		offset += block.text.length + 1;
+	}
+	return {
+		blockStartOffsets,
+		blocks,
+		text: blocks.map((block) => block.text).join("\n")
+	};
+}
+//#endregion
+//#region src/shared/markdown/blockAtOffset.ts
+/**
+* Finds the block holding a character of a doc's canonical text
+*
+* @param documentText the doc's canonical text
+* @param offset a position in the canonical text; the "\n" between two blocks belongs to the earlier block
+* @returns the block and the position within its text, clamped to the text's length, or null when the doc has no
+*   blocks
+*/
+function blockAtOffset(documentText, offset) {
+	const { blocks, blockStartOffsets } = documentText;
+	let blockIndex = blocks.length - 1;
+	while (blockIndex > 0 && (blockStartOffsets[blockIndex] ?? 0) > offset) blockIndex -= 1;
+	const block = blocks[blockIndex];
+	if (block === void 0) return null;
+	return {
+		block,
+		offsetInBlock: Math.min(Math.max(0, offset - (blockStartOffsets[blockIndex] ?? 0)), block.text.length)
+	};
+}
+//#endregion
+//#region src/shared/markdown/lineAtOffset.ts
+/**
+* Finds the source line holding a character of a doc's canonical text
+*
+* @param documentText the doc's canonical text
+* @param offset a position in the canonical text; the "\n" between two blocks belongs to the earlier block
+* @returns the 1-based source line, or 1 when the doc has no blocks; never later than the true line
+*/
+function lineAtOffset(documentText, offset) {
+	const position = blockAtOffset(documentText, offset);
+	if (position === null) return 1;
+	const { block, offsetInBlock } = position;
+	return block.lineOffsets.findLast((lineOffset) => lineOffset.offset <= offsetInBlock)?.line ?? block.startLine;
+}
+//#endregion
+//#region src/shared/markdown/linesForRange.ts
+/**
+* Finds the source lines holding a range of a doc's canonical text
+*
+* @param documentText the doc's canonical text
+* @param startOffset where the range starts
+* @param endOffset where the range ends, exclusive
+* @returns the lines holding the first and last characters of the range; when a block's lines are not exact, the range
+*   runs to the end of that block, so it always contains the text
+*/
+function linesForRange(documentText, startOffset, endOffset) {
+	const lastOffset = Math.max(startOffset, endOffset - 1);
+	const lastBlock = blockAtOffset(documentText, lastOffset)?.block;
+	return {
+		endLine: lastBlock?.exactLines === false ? lastBlock.endLine : lineAtOffset(documentText, lastOffset),
+		startLine: lineAtOffset(documentText, startOffset)
+	};
+}
+//#endregion
+//#region src/server/anchoring/reanchorPassage.ts
+var maxErrorRatio = .2;
+/**
+* Moves a passage anchor to where its text is in the current version of its doc
+*
+* @param anchor the anchor as last computed
+* @param documentText the canonical text of the doc as it is now
+* @returns the anchor on the best exact or approximate match, or the anchor marked outdated, with its old position
+*   clamped to the doc, when nothing matches
+*/
+function reanchorPassage(anchor, documentText) {
+	const candidates = exactCandidates(anchor.anchoredText, documentText.text);
+	const best = chooseCandidate(candidates.length > 0 ? candidates : approximateCandidates(anchor.anchoredText, documentText.text), anchor, documentText.text);
+	if (best === void 0) return {
+		...anchor,
+		endOffset: Math.min(anchor.endOffset, documentText.text.length),
+		outdated: true,
+		startOffset: Math.min(anchor.startOffset, documentText.text.length)
+	};
+	const { end, start } = best;
+	return {
+		...anchor,
+		...linesForRange(documentText, start, end),
+		anchoredText: documentText.text.slice(start, end),
+		endOffset: end,
+		outdated: false,
+		prefix: documentText.text.slice(Math.max(0, start - 32), start),
+		startOffset: start,
+		suffix: documentText.text.slice(end, end + 32)
+	};
+}
+function exactCandidates(pattern, text) {
+	if (pattern === "") return [];
+	const candidates = [];
+	for (let start = text.indexOf(pattern); start !== -1; start = text.indexOf(pattern, start + 1)) candidates.push({
+		end: start + pattern.length,
+		errors: 0,
+		start
+	});
+	return candidates;
+}
+function approximateCandidates(pattern, text) {
+	const maxErrors = Math.floor(maxErrorRatio * pattern.length);
+	return maxErrors === 0 ? [] : search(text, pattern, maxErrors);
+}
+function chooseCandidate(candidates, anchor, text) {
+	const ranked = candidates.map((candidate) => ({
+		candidate,
+		contextScore: contextScore(candidate, anchor, text),
+		distance: Math.abs(candidate.start - anchor.startOffset)
+	}));
+	ranked.sort((left, right) => left.candidate.errors - right.candidate.errors || right.contextScore - left.contextScore || left.distance - right.distance);
+	return ranked[0]?.candidate;
+}
+function contextScore({ end, start }, { prefix, suffix }, text) {
+	const textBefore = text.slice(Math.max(0, start - prefix.length), start);
+	const textAfter = text.slice(end, end + suffix.length);
+	return commonSuffixLength(prefix, textBefore) + commonPrefixLength(suffix, textAfter);
+}
+function commonPrefixLength(left, right) {
+	let length = 0;
+	while (length < left.length && left[length] === right[length]) length += 1;
+	return length;
+}
+function commonSuffixLength(left, right) {
+	let length = 0;
+	while (length < left.length && left[left.length - 1 - length] === right[right.length - 1 - length]) length += 1;
+	return length;
+}
+//#endregion
+//#region src/server/anchoring/anchorNewPassage.ts
+/**
+* Anchors a passage the user has just selected
+*
+* @param newAnchor the selection, as offsets and text in the doc the browser rendered
+* @param source the doc's current source
+* @param renderedHash the hash of the source the browser rendered, if it sent one
+* @returns the anchor at the selected offsets when the browser rendered the current source, otherwise the anchor
+*   re-anchored against the current source
+*/
+function anchorNewPassage(newAnchor, source, renderedHash) {
+	const documentText = createDocumentText(source);
+	const { endOffset, quote, startOffset } = newAnchor;
+	const anchor = {
+		...newAnchor,
+		...linesForRange(documentText, startOffset, endOffset),
+		anchoredText: quote,
+		outdated: false
+	};
+	return renderedHash === hashSource(source) && documentText.text.slice(startOffset, endOffset) === quote ? anchor : reanchorPassage(anchor, documentText);
+}
+//#endregion
+//#region src/server/anchoring/reanchorDocumentThreads.ts
+/**
+* Brings the passage threads of a doc up to date with its source
+*
+* @param threads the doc's threads, of any status
+* @param source the doc's current source, or null when the doc no longer exists
+* @returns the threads with every passage anchor moved to its text, or marked outdated; other threads unchanged
+*/
+function reanchorDocumentThreads(threads, source) {
+	const documentText = source === null ? null : createDocumentText(source);
+	return threads.map((thread) => {
+		if (thread.anchor.kind !== "passage") return thread;
+		const anchor = documentText === null ? {
+			...thread.anchor,
+			outdated: true
+		} : reanchorPassage(thread.anchor, documentText);
+		return {
+			...thread,
+			anchor
+		};
+	});
+}
+//#endregion
+//#region src/server/store/emptyReviewFile.ts
+var emptyReviewFile = {
+	approvedAt: null,
+	requestedAt: null,
+	threads: [],
+	version: 1
+};
+//#endregion
+//#region src/server/store/needsAgent.ts
+/**
+* Tells whether a thread is waiting for the agent
+*
+* @param thread the thread
+* @returns true when the thread is open and the user had the last word
+*/
+function needsAgent(thread) {
+	return thread.status === "open" && thread.messages.at(-1)?.author === "user";
+}
+//#endregion
+//#region src/server/store/OperationQueue.ts
+/**
+* Serialises asynchronous operations so they run one at a time in call order
+*/
+var OperationQueue = class {
+	queue = Promise.resolve();
+	/**
+	* Runs a task after all previous tasks in this queue have settled
+	*
+	* @param task the asynchronous operation to run
+	* @returns a promise that resolves to the task's result
+	*/
+	enqueue(task) {
+		const result = this.queue.then(task);
+		this.queue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+//#endregion
+//#region src/server/store/renumberDuplicateThreads.ts
+/**
+* Gives every thread a unique ID after a merge has brought in threads that share one
+*
+* @param files the threads of every store file
+* @returns the files with the later-created thread of each clash moved to the next free ID, and what was moved
+*/
+function renumberDuplicateThreads(files) {
+	const entries = files.flatMap((file, fileIndex) => file.threads.map((thread) => ({
+		fileIndex,
+		thread
+	})));
+	entries.sort((left, right) => left.thread.id - right.thread.id || Date.parse(left.thread.createdAt) - Date.parse(right.thread.createdAt) || left.fileIndex - right.fileIndex);
+	let nextId = Math.max(0, ...entries.map(({ thread }) => thread.id)) + 1;
+	const newIds = /* @__PURE__ */ new Map();
+	entries.forEach(({ thread }, index) => {
+		if (entries[index - 1]?.thread.id === thread.id) {
+			newIds.set(thread, nextId);
+			nextId += 1;
+		}
+	});
+	const renumberings = [];
+	return {
+		files: files.map((file) => ({
+			...file,
+			threads: file.threads.map((thread) => {
+				const to = newIds.get(thread);
+				if (to === void 0) return thread;
+				renumberings.push({
+					document: file.document,
+					from: thread.id,
+					to
+				});
+				return {
+					...thread,
+					id: to
+				};
+			})
+		})),
+		renumberings
+	};
+}
+//#endregion
+//#region src/shared/review/documentThreadsFileSchema.ts
+var documentThreadsFileSchema = z.strictObject({
+	document: documentPathSchema,
+	sourceHash: z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+	threads: z.array(threadSchema),
+	version: z.literal(1)
+}).refine((file) => file.threads.every((thread) => thread.anchor.kind !== "review" && thread.anchor.document === file.document), { message: "must hold only threads anchored to its own doc" });
+//#endregion
+//#region src/shared/review/reviewFileSchema.ts
+var reviewFileSchema = z.strictObject({
+	approvedAt: z.iso.datetime().nullable(),
+	requestedAt: z.iso.datetime().nullable(),
+	threads: z.array(threadSchema),
+	version: z.literal(1)
+}).refine((file) => file.threads.every((thread) => thread.anchor.kind === "review"), { message: "must hold only threads on the whole review" });
+//#endregion
+//#region src/server/files/writeTextFileUnlessExists.ts
+/**
+* Creates a UTF-8 text file, leaving any file already at that path alone
+*
+* @param filePath the file to create
+* @param contents the text to write
+* @returns true when the file was created; false when a file already existed, so nothing was written
+* @throws the file system error for any other failure
+*/
+async function writeTextFileUnlessExists(filePath, contents) {
+	try {
+		await writeFile(filePath, contents, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") return false;
+		throw error;
+	}
+}
+//#endregion
+//#region src/server/store/StoreFiles.ts
+/**
+* Reads and writes the files of one root's `.markdown-review/` directory and the docs they refer to
+*/
+var StoreFiles = class {
+	root;
+	constructor(root) {
+		this.root = root;
+	}
+	/**
+	* Creates the store directory, and a `.gitignore` that keeps it out of git unless the user has written their own
+	*/
+	async ensureStoreDirectory() {
+		await mkdir(storeDirectory(this.root), { recursive: true });
+		await writeTextFileUnlessExists(path.join(storeDirectory(this.root), ".gitignore"), "*\n");
+	}
+	/**
+	* @returns the review file, or an empty one when it does not exist yet
+	*/
+	async readReviewFile() {
+		const result = await readStoreFile(reviewFilePath(this.root), reviewFileSchema);
+		return result.kind === "valid" ? {
+			kind: "valid",
+			value: result.value ?? emptyReviewFile
+		} : result;
+	}
+	/**
+	* @throws StoreError "invalid-input" when the file would not pass validation when read back
+	*/
+	async writeReviewFile(file) {
+		await writeJsonAtomically(reviewFilePath(this.root), parseStoreInput(reviewFileSchema, file, "The review file"));
+	}
+	/**
+	* @returns the repo-relative paths of the docs that have a threads file
+	*/
+	async listDocuments() {
+		let entries;
+		try {
+			entries = await readdir(documentsDirectory(this.root), { recursive: true });
+		} catch (error) {
+			if (isFileNotFound(error)) return [];
+			throw error;
+		}
+		return entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -5).split(path.sep).join("/")).sort();
+	}
+	/**
+	* @param document a repo-relative POSIX path
+	* @returns the doc's threads file as stored, or null when the doc has none
+	*/
+	readDocumentFile(document) {
+		return readStoreFile(documentThreadsFilePath(this.root, document), documentThreadsFileSchema);
+	}
+	/**
+	* @throws StoreError "invalid-input" when the file would not pass validation when read back
+	*/
+	async writeDocumentFile(file) {
+		const valid = parseStoreInput(documentThreadsFileSchema, file, `The threads file for ${file.document}`);
+		await writeJsonAtomically(documentThreadsFilePath(this.root, valid.document), valid);
+	}
+	/**
+	* @param document a repo-relative POSIX path
+	* @returns the doc's markdown source, or null when it does not exist
+	*/
+	readDocumentSource(document) {
+		return readTextFileOrNull(documentSourcePath(this.root, document));
+	}
+};
+//#endregion
+//#region src/server/store/threadTransitions.ts
+/**
+* Starts a thread holding the user's comment as a draft
+*
+* @param id the new thread's ID
+* @param anchor what the comment is on
+* @param body the comment
+* @param at the current time, ISO 8601
+* @returns the draft thread
+*/
+function createDraftThread(id, anchor, body, at) {
+	return {
+		anchor,
+		createdAt: at,
+		draft: {
+			at,
+			body
+		},
+		id,
+		messages: [],
+		status: "draft",
+		updatedAt: at
+	};
+}
+/**
+* Sets the user's unsubmitted text: the comment on a draft thread, otherwise a reply
+*
+* @param thread the thread
+* @param body the text
+* @param at the current time, ISO 8601
+* @returns the thread with its draft replaced
+*/
+function writeDraft(thread, body, at) {
+	return {
+		...thread,
+		draft: {
+			at,
+			body
+		},
+		updatedAt: at
+	};
+}
+/**
+* Discards the user's unsubmitted text
+*
+* @param thread the thread
+* @param at the current time, ISO 8601
+* @returns the thread without its draft, or null when it was a draft thread, which no longer exists
+* @throws StoreError "invalid-state" when the thread has no draft
+*/
+function deleteDraft(thread, at) {
+	if (thread.draft === void 0) throw new StoreError("invalid-state", `Thread #${thread.id} has no draft to delete`);
+	if (thread.status === "draft") return null;
+	return {
+		...withoutDraft(thread),
+		updatedAt: at
+	};
+}
+/**
+* Resolves a thread at the user's request; a pending draft reply is kept
+*
+* @param thread the thread
+* @param at the current time, ISO 8601
+* @returns the resolved thread, unchanged when it was already resolved
+* @throws StoreError "invalid-state" when the thread is a draft
+*/
+function resolveAsUser(thread, at) {
+	if (thread.status === "draft") throw new StoreError("invalid-state", `Thread #${thread.id} is a draft; delete it instead of resolving it`);
+	if (thread.status === "resolved") return thread;
+	return {
+		...thread,
+		status: "resolved",
+		updatedAt: at
+	};
+}
+/**
+* Turns the user's draft into a submitted message, opening the thread
+*
+* @param thread the thread
+* @param at the submit time, ISO 8601, which the message is stamped with
+* @returns the open thread with the draft appended as a user message, or the thread unchanged when it has no draft
+*/
+function submitDraft(thread, at) {
+	if (thread.draft === void 0) return thread;
+	return {
+		...withoutDraft(thread),
+		messages: [...thread.messages, {
+			at,
+			author: "user",
+			body: thread.draft.body
+		}],
+		status: "open",
+		updatedAt: at
+	};
+}
+/**
+* Adds the agent's answer to a thread without changing its status
+*
+* @param thread a thread that is not a draft
+* @param body the answer
+* @param at the current time, ISO 8601
+* @returns the thread with the agent message appended
+*/
+function replyAsAgent(thread, body, at) {
+	return {
+		...thread,
+		messages: [...thread.messages, {
+			at,
+			author: "agent",
+			body
+		}],
+		updatedAt: at
+	};
+}
+/**
+* Resolves a thread at the agent's request
+*
+* @param thread a thread that is not a draft
+* @param body what the agent changed, or null to resolve without a message
+* @param at the current time, ISO 8601
+* @returns the resolved thread
+*/
+function resolveAsAgent(thread, body, at) {
+	return {
+		...body === null ? thread : replyAsAgent(thread, body, at),
+		status: "resolved",
+		updatedAt: at
+	};
+}
+function withoutDraft(thread) {
+	const next = { ...thread };
+	delete next.draft;
+	return next;
+}
+//#endregion
+//#region src/server/store/toReviewState.ts
+/**
+* Works out whether the current review round is approved
+*
+* @param reviewFile the review's stored timestamps
+* @returns the timestamps and whether the approval came after the latest request
+*/
+function toReviewState({ approvedAt, requestedAt }) {
+	return {
+		approved: approvedAt !== null && (requestedAt === null || Date.parse(approvedAt) > Date.parse(requestedAt)),
+		approvedAt,
+		requestedAt
+	};
+}
+//#endregion
+//#region src/server/store/ReviewStore.ts
+/**
+* Holds one root's review threads and carries out every change to them, one at a time
+*/
+var ReviewStore = class {
+	files;
+	logger;
+	queue = new OperationQueue();
+	/**
+	* @param root the repo root whose `.markdown-review/` directory holds the threads
+	* @param logger where store files that cannot be read, and repairs to the store, are reported
+	*/
+	constructor(root, logger) {
+		this.files = new StoreFiles(root);
+		this.logger = logger;
+	}
+	/**
+	* Creates the store directory if needed and gives threads that share an ID, after a merge, unique IDs
+	*/
+	initialize() {
+		return this.queue.enqueue(async () => {
+			await this.files.ensureStoreDirectory();
+			const { problems } = await this.readAllStoredThreads();
+			problems.forEach((problem) => this.logger.warn(problem));
+		});
+	}
+	/**
+	* Starts a review round, so an earlier approval no longer counts
+	*
+	* @returns the review state after the request
+	*/
+	requestReview() {
+		return this.queue.enqueue(async () => {
+			const next = {
+				...requireValid(await this.files.readReviewFile()),
+				requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await this.files.writeReviewFile(next);
+			return toReviewState(next);
+		});
+	}
+	/**
+	* Saves a new comment as a draft thread
+	*
+	* @param newThread the comment and what it is on
+	* @returns the draft thread
+	* @throws StoreError "invalid-input" when the comment is malformed, or "missing-document" when its doc does not exist
+	*/
+	createDraftThread(newThread) {
+		return this.queue.enqueue(async () => {
+			const { anchor, body, renderedHash } = parseStoreInput(newThreadSchema, newThread, "The new thread");
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			const id = await this.nextThreadId();
+			if (anchor.kind === "review") {
+				const review = requireValid(await this.files.readReviewFile());
+				const thread = createDraftThread(id, anchor, body, at);
+				await this.files.writeReviewFile({
+					...review,
+					threads: [...review.threads, thread]
+				});
+				return thread;
+			}
+			const { file, source } = await this.readCurrentDocumentFile(anchor.document);
+			if (source === null) throw new StoreError("missing-document", `${anchor.document} does not exist`);
+			const thread = createDraftThread(id, anchor.kind === "document" ? anchor : anchorNewPassage(anchor, source, renderedHash), body, at);
+			await this.files.writeDocumentFile({
+				...file,
+				threads: [...file.threads, thread]
+			});
+			return thread;
+		});
+	}
+	/**
+	* Sets the user's unsubmitted comment or reply on a thread
+	*
+	* @throws StoreError "unknown-thread" when no thread has the ID, or "invalid-input" when the text is blank
+	*/
+	writeDraft(id, body) {
+		return this.changeThread(id, "user", (thread, at) => writeDraft(thread, parseStoreInput(messageBodySchema, body, "The draft"), at));
+	}
+	/**
+	* Discards the user's unsubmitted comment or reply on a thread
+	*
+	* @returns the thread without its draft, or null when it was a draft thread and has been deleted
+	* @throws StoreError "unknown-thread", or "invalid-state" when the thread has no draft
+	*/
+	deleteDraft(id) {
+		return this.changeThread(id, "user", deleteDraft);
+	}
+	/**
+	* @throws StoreError "unknown-thread", or "invalid-state" when the thread is a draft
+	*/
+	resolveAsUser(id) {
+		return this.changeThread(id, "user", resolveAsUser);
+	}
+	/**
+	* Submits every draft in the repo and records the user's verdict on the review round
+	*
+	* @param verdict "approve" ends the round; "request-changes" needs at least one draft
+	* @returns the IDs of the threads that received a submitted message, and the review state after the submit
+	* @throws StoreError "invalid-state" when requesting changes with no drafts
+	*/
+	submit(verdict) {
+		return this.queue.enqueue(async () => {
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			const review = requireValid(await this.files.readReviewFile());
+			const documentFiles = await this.readDocumentFilesWithDrafts();
+			const submittedThreadIds = [...review.threads, ...documentFiles.flatMap((file) => file.threads)].filter((thread) => thread.draft !== void 0).map((thread) => thread.id).sort((left, right) => left - right);
+			if (verdict === "request-changes" && submittedThreadIds.length === 0) throw new StoreError("invalid-state", "There are no drafts to submit");
+			for (const file of documentFiles) await this.files.writeDocumentFile({
+				...file,
+				threads: file.threads.map((thread) => submitDraft(thread, at))
+			});
+			const next = {
+				...review,
+				approvedAt: verdict === "approve" ? at : null,
+				threads: review.threads.map((thread) => submitDraft(thread, at))
+			};
+			await this.files.writeReviewFile(next);
+			return {
+				review: toReviewState(next),
+				submittedThreadIds
+			};
+		});
+	}
+	/**
+	* @throws StoreError "unknown-thread" when no thread has the ID or the thread is a draft, or "invalid-input" when
+	*   the reply is blank
+	*/
+	replyAsAgent(id, body) {
+		return this.changeThread(id, "agent", (thread, at) => replyAsAgent(thread, parseStoreInput(messageBodySchema, body, "The reply"), at));
+	}
+	/**
+	* @param body what the agent changed, or null to resolve without a message
+	* @throws StoreError "unknown-thread" when no thread has the ID or the thread is a draft, or "invalid-input" when
+	*   the message is blank
+	*/
+	resolveAsAgent(id, body) {
+		return this.changeThread(id, "agent", (thread, at) => resolveAsAgent(thread, body === null ? null : parseStoreInput(messageBodySchema, body, "The message"), at));
+	}
+	/**
+	* Reads threads for the browser, first re-anchoring any doc that changed since its threads were last anchored
+	*
+	* @param document the doc whose threads to read, alongside the review's, or null for every thread
+	* @returns the review state, the threads in ID order, and any store files that could not be read
+	* @throws StoreError "invalid-input" when the doc path is not a repo-relative POSIX path
+	*/
+	readThreads(document) {
+		return this.queue.enqueue(() => this.readSnapshot(document));
+	}
+	/**
+	* Reads what the agent has to act on, first re-anchoring any doc that changed since its threads were last anchored
+	*
+	* @param document the doc to limit the threads to, or null for every thread including the review's
+	* @returns the review state and the threads that need the agent
+	* @throws StoreError "invalid-input" when the doc path is not a repo-relative POSIX path
+	*/
+	readInbox(document) {
+		return this.queue.enqueue(async () => {
+			const snapshot = await this.readSnapshot(document);
+			const threads = snapshot.threads.filter((thread) => needsAgent(thread) && (document === null || thread.anchor.kind !== "review"));
+			return {
+				...snapshot,
+				threads
+			};
+		});
+	}
+	async readSnapshot(document) {
+		const documents = document === null ? await this.files.listDocuments() : [parseStoreInput(documentPathSchema, document, "The doc path")];
+		await this.readAllStoredThreads();
+		const problems = [];
+		const review = await this.readReviewFileOrReport(problems);
+		const threads = [...review.threads];
+		for (const name of documents) threads.push(...await this.readDocumentThreadsOrReport(name, problems));
+		return {
+			problems,
+			review: toReviewState(review),
+			threads: threads.sort((left, right) => left.id - right.id)
+		};
+	}
+	async readReviewFileOrReport(problems) {
+		const result = await this.files.readReviewFile();
+		if (result.kind === "invalid") {
+			problems.push(result.problem);
+			return emptyReviewFile;
+		}
+		return result.value;
+	}
+	async readDocumentThreadsOrReport(document, problems) {
+		try {
+			return (await this.readCurrentDocumentFile(document)).file.threads;
+		} catch (error) {
+			if (error instanceof StoreError && error.reason === "invalid-file") {
+				problems.push(error.message);
+				return [];
+			}
+			throw error;
+		}
+	}
+	changeThread(id, actor, change) {
+		return this.queue.enqueue(async () => {
+			const document = await this.locateThread(id);
+			const threads = document === null ? requireValid(await this.files.readReviewFile()).threads : (await this.readCurrentDocumentFile(document)).file.threads;
+			const thread = threads.find((candidate) => candidate.id === id);
+			if (thread === void 0 || actor === "agent" && thread.status === "draft") throw new StoreError("unknown-thread", `No thread #${id}`);
+			const changed = change(thread, (/* @__PURE__ */ new Date()).toISOString());
+			await this.replaceThreads(document, replaceThread(threads, id, changed));
+			return changed;
+		});
+	}
+	/**
+	* @returns the doc whose threads file holds the thread, or null when `review.json` does
+	* @throws StoreError "unknown-thread" when no readable store file holds it
+	*/
+	async locateThread(id) {
+		const { files } = await this.readAllStoredThreads();
+		const file = files.find((candidate) => candidate.threads.some((thread) => thread.id === id));
+		if (file === void 0) throw new StoreError("unknown-thread", `No thread #${id}`);
+		return file.document;
+	}
+	async nextThreadId() {
+		const { files } = await this.readAllStoredThreads();
+		return Math.max(0, ...files.flatMap((file) => file.threads.map((thread) => thread.id))) + 1;
+	}
+	/**
+	* Reads the threads of every readable store file, first giving threads that share an ID, after a merge or a pull,
+	* unique IDs, so an ID always names one thread
+	*/
+	async readAllStoredThreads() {
+		const { files, problems } = await this.readStoredThreadFiles();
+		const { files: renumbered, renumberings } = renumberDuplicateThreads(files);
+		const changedDocuments = new Set(renumberings.map(({ document }) => document));
+		for (const { document, threads } of renumbered) if (changedDocuments.has(document)) await this.replaceThreads(document, threads);
+		for (const { document, from, to } of renumberings) this.logger.info(`Thread #${from} in ${document ?? "the review"} was renumbered to #${to} because its ID was taken`);
+		return {
+			files: renumbered,
+			problems
+		};
+	}
+	async readStoredThreadFiles() {
+		const files = [];
+		const problems = [];
+		const review = await this.files.readReviewFile();
+		if (review.kind === "valid") files.push({
+			document: null,
+			threads: review.value.threads
+		});
+		else problems.push(review.problem);
+		for (const document of await this.files.listDocuments()) {
+			const result = await this.files.readDocumentFile(document);
+			if (result.kind === "invalid") problems.push(result.problem);
+			else if (result.value !== null) files.push({
+				document,
+				threads: result.value.threads
+			});
+		}
+		return {
+			files,
+			problems
+		};
+	}
+	async readDocumentFilesWithDrafts() {
+		const files = [];
+		for (const document of await this.files.listDocuments()) {
+			const result = await this.files.readDocumentFile(document);
+			if (result.kind === "invalid") this.logger.warn(`Drafts in ${document} were not submitted. ${result.problem}`);
+			else if (result.value?.threads.some((thread) => thread.draft !== void 0)) files.push((await this.readCurrentDocumentFile(document)).file);
+		}
+		return files;
+	}
+	/**
+	* Reads a doc's threads file, first re-anchoring its passage threads and saving them when the doc has changed since
+	* they were last anchored
+	*/
+	async readCurrentDocumentFile(document) {
+		const stored = requireValid(await this.files.readDocumentFile(document));
+		if (stored !== null && stored.document !== document) throw new StoreError("invalid-input", `${document} has its threads stored as ${stored.document}; use that name`);
+		const source = await this.files.readDocumentSource(document);
+		const sourceHash = source === null ? null : hashSource(source);
+		if (stored === null) return {
+			file: {
+				document,
+				sourceHash,
+				threads: [],
+				version: 1
+			},
+			source
+		};
+		if (stored.sourceHash === sourceHash) return {
+			file: stored,
+			source
+		};
+		const file = {
+			...stored,
+			sourceHash,
+			threads: reanchorDocumentThreads(stored.threads, source)
+		};
+		await this.files.writeDocumentFile(file);
+		return {
+			file,
+			source
+		};
+	}
+	async replaceThreads(document, threads) {
+		if (document === null) {
+			const review = requireValid(await this.files.readReviewFile());
+			await this.files.writeReviewFile({
+				...review,
+				threads
+			});
+			return;
+		}
+		const file = requireValid(await this.files.readDocumentFile(document));
+		if (file === null) throw new StoreError("invalid-state", `${document} has no threads file to update`);
+		await this.files.writeDocumentFile({
+			...file,
+			threads
+		});
+	}
+};
+function replaceThread(threads, id, replacement) {
+	return threads.flatMap((thread) => {
+		if (thread.id !== id) return [thread];
+		return replacement === null ? [] : [replacement];
+	});
+}
+function requireValid(result) {
+	if (result.kind === "invalid") throw new StoreError("invalid-file", result.problem);
+	return result.value;
+}
+//#endregion
+//#region src/server/runtime/ActivityMonitor.ts
+/**
+* Tracks connected tabs and waiting polls, reports whether the agent is waiting, and notices when the server is idle
+*/
+var ActivityMonitor = class {
+	browsers = 0;
+	events;
+	idleMilliseconds;
+	idleTimer;
+	onIdle;
+	polls = 0;
+	constructor({ events, idleMilliseconds, onIdle }) {
+		this.events = events;
+		this.idleMilliseconds = idleMilliseconds;
+		this.onIdle = onIdle;
+		this.restartIdleTimer();
+	}
+	get agentWaiting() {
+		return this.polls > 0;
+	}
+	/**
+	* Records a request, which restarts the idle countdown
+	*/
+	touch() {
+		this.restartIdleTimer();
+	}
+	/**
+	* @returns a function to call when the tab disconnects
+	*/
+	beginBrowser() {
+		this.browsers += 1;
+		this.restartIdleTimer();
+		return this.once(() => {
+			this.browsers -= 1;
+			this.restartIdleTimer();
+		});
+	}
+	/**
+	* @returns a function to call when the poll ends
+	*/
+	beginPoll() {
+		this.polls += 1;
+		this.restartIdleTimer();
+		if (this.polls === 1) this.events.publish({
+			agentWaiting: true,
+			type: "presence"
+		});
+		return this.once(() => {
+			this.polls -= 1;
+			this.restartIdleTimer();
+			if (this.polls === 0) this.events.publish({
+				agentWaiting: false,
+				type: "presence"
+			});
+		});
+	}
+	stop() {
+		clearTimeout(this.idleTimer);
+	}
+	restartIdleTimer() {
+		clearTimeout(this.idleTimer);
+		this.idleTimer = this.browsers === 0 && this.polls === 0 ? setTimeout(this.onIdle, this.idleMilliseconds).unref() : void 0;
+	}
+	once(end) {
+		let ended = false;
+		return () => {
+			if (!ended) {
+				ended = true;
+				end();
+			}
+		};
+	}
+};
+//#endregion
+//#region src/server/runtime/DocumentWatcher.ts
+/**
+* Watches docs for edits, so connected tabs can be told as soon as the agent saves one
+*/
+var DocumentWatcher = class {
+	documents = /* @__PURE__ */ new Map();
+	root;
+	watcher;
+	/**
+	* @param root the repo root
+	* @param onChange called with a doc's repo-relative path when it is written, created or deleted
+	*/
+	constructor(root, onChange) {
+		this.root = root;
+		this.watcher = watch([], {
+			atomic: true,
+			awaitWriteFinish: {
+				pollInterval: 20,
+				stabilityThreshold: 50
+			},
+			ignoreInitial: true
+		});
+		this.watcher.on("all", (_event, changedPath) => {
+			const document = this.documents.get(changedPath);
+			if (document !== void 0) onChange(document);
+		});
+	}
+	/**
+	* @param document a repo-relative POSIX path; watching a doc twice has no further effect
+	*/
+	watch(document) {
+		const absolutePath = path.join(this.root, ...document.split("/"));
+		if (!this.documents.has(absolutePath)) {
+			this.documents.set(absolutePath, document);
+			this.watcher.add(absolutePath);
+		}
+	}
+	close() {
+		return this.watcher.close();
+	}
+};
+//#endregion
+//#region src/server/runtime/preferredPort.ts
+var firstDynamicPort = 49152;
+var dynamicPortCount = 16384;
+/**
+* Picks the port a root's server tries first, so a restarted server usually comes back on the same port
+*
+* @param root the repo root
+* @returns a port in the dynamic range 49152-65535, the same for the same root
+*/
+function preferredPort(root) {
+	return firstDynamicPort + createHash("sha256").update(root, "utf8").digest().readUInt32BE(0) % dynamicPortCount;
+}
+//#endregion
+//#region src/server/runtime/runServer.ts
+/**
+* Starts the root's review server on 127.0.0.1 and records it in `.markdown-review/server.json`
+*
+* @returns the running server; it removes `server.json` when it stops
+*/
+async function runServer({ idleMilliseconds = 18e5, logger, pollKeepAliveMilliseconds = 15e3, root, webDirectory }) {
+	const store = new ReviewStore(root, logger);
+	await store.initialize();
+	const events = new ServerEvents();
+	let port = 0;
+	let stopping;
+	let markClosed = () => {};
+	const closed = new Promise((resolve) => {
+		markClosed = resolve;
+	});
+	const close = () => {
+		stopping ??= stop();
+		return stopping;
+	};
+	const closeInBackground = () => {
+		close().catch((error) => logger.error("The server did not stop cleanly", error));
+	};
+	const activity = new ActivityMonitor({
+		events,
+		idleMilliseconds,
+		onIdle: closeInBackground
+	});
+	const watcher = new DocumentWatcher(root, (document) => {
+		store.readThreads(document).then(() => {
+			events.publish({
+				document,
+				type: "document-changed"
+			});
+			events.publish({ type: "threads-changed" });
+		}).catch((error) => logger.warn(`Could not re-anchor ${document} after it changed`, error));
+	});
+	const token = randomBytes(32).toString("hex");
+	const app = createApp({
+		activity,
+		events,
+		logger,
+		pollKeepAliveMilliseconds,
+		port: () => port,
+		recentDocuments: new RecentDocuments(),
+		root,
+		shutdown: closeInBackground,
+		store,
+		tabs: new BrowserTabs(),
+		token,
+		version: packageVersion,
+		watchDocument: (document) => watcher.watch(document),
+		webDirectory
+	});
+	const server = createServer(getRequestListener(app.fetch));
+	port = await listen(server, preferredPort(root));
+	const serverFile = {
+		pid: process.pid,
+		port,
+		protocol: 1,
+		root,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		token,
+		version: packageVersion
+	};
+	await writeJsonAtomically(serverFilePath(root), serverFile, 384);
+	for (const thread of (await store.readThreads(null)).threads) if (thread.anchor.kind !== "review") watcher.watch(thread.anchor.document);
+	logger.info(`Serving ${root} on http://127.0.0.1:${port}`);
+	async function stop() {
+		activity.stop();
+		await watcher.close();
+		await closeServer(server);
+		await removeServerFile(root);
+		logger.info("Stopped");
+		markClosed();
+	}
+	return {
+		close,
+		closed,
+		port
+	};
+}
+async function listen(server, port) {
+	try {
+		return await listenOn(server, port);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EADDRINUSE") return listenOn(server, 0);
+		throw error;
+	}
+}
+function listenOn(server, port) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			const address = server.address();
+			if (address === null || typeof address === "string") {
+				reject(/* @__PURE__ */ new TypeError("The server is not listening on a TCP port"));
+				return;
+			}
+			resolve(address.port);
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(port, "127.0.0.1");
+	});
+}
+function closeServer(server) {
+	return new Promise((resolve, reject) => {
+		server.close((error) => error === void 0 ? resolve() : reject(error));
+		server.closeAllConnections();
+	});
+}
+/**
+* Removes `server.json` unless a newer server has already replaced it
+*/
+async function removeServerFile(root) {
+	const contents = await readTextFileOrNull(serverFilePath(root));
+	if (contents === null) return;
+	let recorded;
+	try {
+		recorded = JSON.parse(contents);
+	} catch {
+		return;
+	}
+	if (serverFileSchema.safeParse(recorded).data?.pid === process.pid) await rm(serverFilePath(root), { force: true });
+}
+//#endregion
+//#region src/cli/commands/serveCommand.ts
+/**
+* Runs the review server in this process until it stops; the CLI starts it detached as `serve --root <root>`
+*/
+async function serveCommand(args, { cliPath }) {
+	const { values } = parseArgs({
+		args,
+		options: { root: { type: "string" } }
+	});
+	if (values.root === void 0) throw new CliError("serve needs --root <path>", "Run `markdown-review serve --root <repository root>`.", 2);
+	const server = await runServer({
+		logger: createConsoleLogger(),
+		root: values.root,
+		webDirectory: path.join(path.dirname(cliPath), "web")
+	});
+	const stop = () => {
+		server.close().catch((error) => process.stderr.write(`The server did not stop cleanly: ${String(error)}\n`));
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	await server.closed;
+	return 0;
+}
+//#endregion
+//#region src/cli/commands/stopCommand.ts
+async function stopCommand(args, { terminal }) {
+	parseArgs({
+		args,
+		options: {}
+	});
+	const root = await findRoot(terminal.workingDirectory);
+	const found = await findServer(root);
+	if (found.kind !== "ready" && found.kind !== "older") {
+		terminal.stdout(`No review server is running for ${root} that this markdown-review can stop.\n\nnext_step: None.\n`);
+		return 0;
+	}
+	await found.client.shutdown();
+	await waitUntilStopped(found.client);
+	terminal.stdout(`Stopped the review server for ${root}.\n\nnext_step: None; any markdown-review command starts it again.\n`);
+	return 0;
+}
+//#endregion
+//#region src/cli/helpText.ts
+var commandHelp = {
+	inbox: ["markdown-review inbox [--document <path>]", "  Print whether the review is approved and the threads that need you, then return at once."].join("\n"),
+	"install-skill": [
+		"markdown-review install-skill [--global]",
+		"  Install the skill that teaches agents this workflow in this repository's .claude/skills, or with --global in",
+		"  ~/.claude/skills. Claude Code and OpenCode both read skills from there."
+	].join("\n"),
+	open: ["markdown-review open [path]", "  Start a review round and show the doc (or the docs list) in the user's browser. Prints the URL."].join("\n"),
+	poll: [
+		"markdown-review poll [--document <path>] [--timeout <seconds>]",
+		"  Wait until the user submits or approves, then print what needs you. The timeout defaults to 540 seconds.",
+		"  Give the shell command a timeout of at least 600000 ms, or in Claude Code run it with run_in_background",
+		"  and --timeout 7080."
+	].join("\n"),
+	reply: [
+		"markdown-review reply <id> <text>",
+		"markdown-review reply <id> --file <path>   (--file - reads standard input)",
+		"  Answer a thread without resolving it, for example to ask the user a question."
+	].join("\n"),
+	resolve: [
+		"markdown-review resolve <id> [text]",
+		"markdown-review resolve <id> --file <path>   (--file - reads standard input)",
+		"  Resolve a thread, optionally saying what changed."
+	].join("\n"),
+	stop: ["markdown-review stop", "  Stop the review server for this repository."].join("\n")
+};
+/**
+* @param command a command name, or undefined for every command
+* @returns usage text for the command, or for the whole CLI
+*/
+function helpText(command) {
+	const named = command === void 0 ? void 0 : commandHelp[command];
+	if (named !== void 0) return `${named}\n`;
+	return [
+		"Markdown Review: the user reviews your markdown in a browser; you read and answer their comments here.",
+		"",
+		...Object.values(commandHelp),
+		"",
+		"Run `markdown-review <command> --help` for one command. Every command ends with a next_step line.",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/cli/runCli.ts
+var commands = {
+	inbox: inboxCommand,
+	"install-skill": installSkillCommand,
+	open: openCommand,
+	poll: pollCommand,
+	reply: replyCommand,
+	resolve: resolveCommand,
+	serve: serveCommand,
+	stop: stopCommand
+};
+/**
+* Runs one CLI invocation
+*
+* @param commandLine the arguments after the program name
+* @param context where to write output and how to start the server
+* @returns the process exit code: 0 on success, 1 when the command failed, 2 for a usage error
+*/
+async function runCli(commandLine, context) {
+	const { terminal } = context;
+	const [name, ...args] = commandLine;
+	if (name === "--version") {
+		terminal.stdout(`${packageVersion}\n`);
+		return 0;
+	}
+	if (name === "--help" || name === "-h" || name === "help") {
+		terminal.stdout(helpText());
+		return 0;
+	}
+	if (name === void 0) {
+		terminal.stderr(`error: no command given\n\n${helpText()}\nnext_step: Run one of the commands above.\n`);
+		return 2;
+	}
+	const command = commands[name];
+	if (command === void 0) {
+		terminal.stderr(`error: unknown command ${name}\n\n${helpText()}\nnext_step: Run one of the commands above.\n`);
+		return 2;
+	}
+	if (args.includes("--help") || args.includes("-h")) {
+		terminal.stdout(helpText(name));
+		return 0;
+	}
+	try {
+		return await command(args, context);
+	} catch (error) {
+		return reportFailure(error, name, context);
+	}
+}
+function reportFailure(error, name, { terminal }) {
+	if (error instanceof CliError) {
+		terminal.stderr(`error: ${error.message}\n\nnext_step: ${error.nextStep}\n`);
+		return error.exitCode;
+	}
+	if (error instanceof ServerRequestError) {
+		terminal.stderr(`error: the review server refused the request: ${error.message}\n\nnext_step: Fix what it reports and run the command again.\n`);
+		return 1;
+	}
+	if (error instanceof TypeError && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS")) {
+		terminal.stderr(`error: ${error.message}\n\nnext_step: Run \`markdown-review ${name} --help\`.\n`);
+		return 2;
+	}
+	terminal.stderr(`error: ${error instanceof Error ? error.message : String(error)}\n\nnext_step: Run the command again; if it keeps failing, read .markdown-review/server.log.\n`);
+	return 1;
+}
+//#endregion
+//#region src/cli/main.ts
+process.exitCode = await runCli(process.argv.slice(2), {
+	cliPath: fileURLToPath(import.meta.url),
+	terminal: createProcessTerminal()
+});
+//#endregion
+export {};