@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/agent-cli-ChOq0ZuO.js

@@ -0,0 +1,117 @@
+import { n as isJsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import { a as toolResultText, i as connectReviewInstance, s as ReviewApiError } from "./agent-client-CPQo7iTI.js";
+import { A as devReviewHome } from "./s3-config-CAxhO9u_.js";
+import { T as traceMachineEnabled } from "./review-home-paths-6zZH-1c9.js";
+import { d as selectReviewInstance, t as REVIEW_INSTANCE_ENV } from "./desktop-discovery-DBO-PM2V.js";
+import { n as reviewSessionAgent } from "./review-telemetry-DEFnQsQ2.js";
+import { n as REVIEW_VIA_HEADER, t as REVIEW_AGENT_HEADER } from "./request-origin-D_4QIdoN.js";
+import { i as publicTool, n as RECOVERY, r as callPublicTool, t as toolFailure } from "./tool-failure-C8zB73HV.js";
+//#region src/review-api/agent-cli.ts
+const reviewAgentCliHelp = "whiteboard api tools  (one line per tool)\nwhiteboard api tools <tool-name>  (its description and input schema)\nwhiteboard api <tool-name> '<json>'\nwhiteboard api <tool-name> -  (read JSON from stdin)\nwhiteboard mcp  (stdio MCP adapter; Whiteboard Desktop or whiteboard server start must be running)\nSelect headless state with DEV_REVIEW_SERVER_DIR or whiteboard --state-dir <path> api/mcp.\n";
+async function runReviewAgentCli(input) {
+	const env = input.env ?? process.env;
+	try {
+		const [mode, ...rest] = input.argv;
+		const [name, json, ...extra] = rest.filter((argument) => argument !== "--json");
+		if (rest.includes("--help") || rest.includes("-h") || mode === "api" && !name) {
+			input.stdout.write(reviewAgentCliHelp);
+			return 0;
+		}
+		if (extra.length || mode === "mcp" && name) throw new Error("Unexpected arguments. Use whiteboard api --help.");
+		const headers = {
+			[REVIEW_VIA_HEADER]: mode === "mcp" ? "mcp" : "api",
+			[REVIEW_AGENT_HEADER]: reviewSessionAgent(env)
+		};
+		if (mode === "mcp") {
+			const { serveReviewMcp } = await import("./mcp-QeF8vkdf.js");
+			await serveReviewMcp(async (key, agentKind) => {
+				const connected = await connectReviewInstance(key ? {
+					...env,
+					[REVIEW_INSTANCE_ENV]: key
+				} : env, agentKind ? {
+					...headers,
+					[REVIEW_AGENT_HEADER]: agentKind
+				} : headers);
+				input.onDesktop?.(connected.instance?.appVersion);
+				return connected;
+			}, input.stdin ?? process.stdin, input.stdout, input.stderr, await traceMachineEnabled({ env: input.env }), env.DEV_REVIEW_SERVER_DIR?.trim() ? void 0 : async (problem) => {
+				const selection = await selectReviewInstance({ env });
+				return {
+					key: selection.key,
+					selectedBy: selection.source,
+					desktopAvailable: false,
+					running: selection.instances.filter((instance) => instance.healthy).map((instance) => instance.key),
+					home: devReviewHome(env),
+					problem
+				};
+			}, input.onToolCall, reviewSessionAgent(env));
+			return 0;
+		}
+		let client;
+		let tools;
+		try {
+			const connected = await connectReviewInstance(input.env, headers);
+			input.onDesktop?.(connected.instance?.appVersion);
+			client = connected.client;
+			tools = (await client.read("/authoring")).map(publicTool);
+		} catch (error) {
+			if (name === "session_get_instructions" && !(error instanceof ReviewApiError)) {
+				input.stderr.write(RECOVERY + "\n");
+				return 1;
+			}
+			throw error;
+		}
+		if (name === "tools") {
+			if (json) {
+				const tool = tools.find((tool) => tool.name === json);
+				if (!tool) throw new Error(`Unknown review tool: ${json}. Use whiteboard api tools.`);
+				input.stdout.write(JSON.stringify(tool, null, 2) + "\n");
+				return 0;
+			}
+			for (const tool of tools) input.stdout.write(`${tool.name}: ${tool.description.split(/(?<=\.)\s/)[0]}\n`);
+			return 0;
+		}
+		const tool = tools.find((tool) => tool.name === name);
+		if (!tool) throw new Error(`Unknown review tool: ${name}. Use whiteboard api tools.`);
+		let source = json ?? "{}";
+		if (source === "-") {
+			if (!input.stdin) throw new Error("No input stream supplied.");
+			source = "";
+			input.stdin.setEncoding("utf8");
+			for await (const chunk of input.stdin) source += chunk;
+		}
+		const args = parseJsonText(source);
+		if (!isJsonObject(args)) throw new Error("Tool input must be a JSON object.");
+		if (name === "session_get" && rest.includes("--json")) args.format = "json";
+		const startedAt = Date.now();
+		let result;
+		try {
+			result = await callPublicTool(client, tool, args);
+		} catch (error) {
+			await input.onToolCall?.({
+				tool: tool.name,
+				via: "api",
+				ok: false,
+				durationMs: Date.now() - startedAt,
+				...toolFailure(error, "call")
+			});
+			throw error;
+		}
+		await input.onToolCall?.({
+			tool: tool.name,
+			via: "api",
+			ok: true,
+			durationMs: Date.now() - startedAt
+		});
+		const text = toolResultText(tool, result);
+		input.stdout.write(text.endsWith("\n") ? text : text + "\n");
+		return 0;
+	} catch (error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		input.onFailure?.(failure);
+		input.stderr.write(failure.message + "\n");
+		return 1;
+	}
+}
+//#endregion
+export { runReviewAgentCli as n, reviewAgentCliHelp as t };

package/dist/agent-cli-DzWfZr6G.js

@@ -0,0 +1,2 @@
+import { n as runReviewAgentCli } from "./agent-cli-ChOq0ZuO.js";
+export { runReviewAgentCli };

package/dist/agent-client-CPQo7iTI.js

@@ -0,0 +1,305 @@
+import { d as isBooleanValue, f as isNumberValue, m as isStringValue, u as parseJsonText } from "./src-X9phtB2j.js";
+import "./src-DnwdaQ2r.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { d as selectReviewInstance, i as healthyReviewInstance, n as ReviewInstanceUnavailableError, u as reviewInstanceUnavailable } from "./desktop-discovery-DBO-PM2V.js";
+import { a as reviewServerIsHealthy, n as readReviewServerDiscovery, o as reviewServerStateDir, s as serverNotReady } from "./server-discovery-Dbzn3w6Z.js";
+//#region ../review-protocol/src/review-api-client.ts
+const defaultRequest = (url, init) => fetch(url, init);
+/** A non-2xx reply; the status tells a caller whether retrying can help. */
+var ReviewApiError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "ReviewApiError";
+	}
+};
+const liveConnections = /* @__PURE__ */ new WeakMap();
+/** Shared by the canvas and thin agent clients; no filesystem or SQL access. */
+var ReviewApiClient = class {
+	connection;
+	request;
+	constructor(connection, request = defaultRequest) {
+		this.connection = connection;
+		this.request = request;
+	}
+	async response(route, init) {
+		const headers = new Headers(init?.headers);
+		headers.set("x-review-token", this.connection.token);
+		if (init?.body) headers.set("content-type", "application/json");
+		const response = await this.request(`${this.connection.serverUrl}/reviews-api${route}`, {
+			...init,
+			headers
+		});
+		if (!response.ok) throw new ReviewApiError((await response.json().catch(() => null))?.error ?? `Review request failed (${response.status}).`, response.status);
+		return response;
+	}
+	async read(route, signal) {
+		return (await this.response(route, { signal })).json();
+	}
+	async post(route, input, signal) {
+		return (await this.response(route, {
+			method: "POST",
+			body: JSON.stringify(input),
+			signal
+		})).json();
+	}
+	async *watch(reviewId, signal) {
+		const reader = (await this.response(Array.isArray(reviewId) ? `/watch?subscriptions=${encodeURIComponent(JSON.stringify(reviewId))}` : reviewId === null ? "/watch" : `/${encodeURIComponent(reviewId)}/watch`, { signal })).body.pipeThrough(new TextDecoderStream()).getReader();
+		const cancel = () => {
+			reader.cancel().catch(() => {});
+		};
+		signal.addEventListener("abort", cancel, { once: true });
+		if (signal.aborted) cancel();
+		let pending = "";
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) return;
+				pending += value;
+				let end;
+				while ((end = pending.indexOf("\n")) !== -1) {
+					yield JSON.parse(pending.slice(0, end));
+					pending = pending.slice(end + 1);
+				}
+			}
+		} finally {
+			signal.removeEventListener("abort", cancel);
+			await reader.cancel().catch(() => {});
+			reader.releaseLock();
+		}
+	}
+	async follow(reviewId, signal, accept, disconnected, mode) {
+		if (signal.aborted) return;
+		let connections = liveConnections.get(this.request);
+		if (!connections) liveConnections.set(this.request, connections = /* @__PURE__ */ new Map());
+		const key = JSON.stringify([this.connection.serverUrl, this.connection.token]);
+		let live = connections.get(key);
+		if (!live) {
+			live = new LiveConnection(this, () => connections.delete(key));
+			connections.set(key, live);
+		}
+		const subscription = { reviewId };
+		if (mode) subscription.mode = mode;
+		return live.add(subscription, signal, (value) => accept(value), disconnected);
+	}
+};
+const restartDelayMs = 20;
+const retryDelayMs = 1e3;
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		const done = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+function report(listener, cause) {
+	if (listener.signal.aborted) return;
+	try {
+		listener.disconnected(cause);
+	} catch {}
+}
+var LiveConnection = class {
+	client;
+	empty;
+	listeners = /* @__PURE__ */ new Set();
+	abort = new AbortController();
+	active = false;
+	scheduled;
+	constructor(client, empty) {
+		this.client = client;
+		this.empty = empty;
+	}
+	add(subscription, signal, accept, disconnected) {
+		const listener = {
+			subscription,
+			signal,
+			accept,
+			disconnected
+		};
+		this.listeners.add(listener);
+		this.restart();
+		return new Promise((resolve) => {
+			const stop = () => {
+				signal.removeEventListener("abort", stop);
+				this.listeners.delete(listener);
+				if (this.listeners.size) this.restart();
+				else {
+					clearTimeout(this.scheduled);
+					this.scheduled = void 0;
+					this.abort.abort();
+					this.active = false;
+					this.empty();
+				}
+				resolve();
+			};
+			signal.addEventListener("abort", stop, { once: true });
+			if (signal.aborted) stop();
+		});
+	}
+	/** The first tab connects at once; later tabs share one replacement stream. */
+	restart() {
+		if (this.scheduled) return;
+		if (!this.active) {
+			this.reconnect();
+			return;
+		}
+		this.scheduled = setTimeout(() => {
+			this.scheduled = void 0;
+			this.reconnect();
+		}, restartDelayMs);
+	}
+	reconnect() {
+		this.abort.abort();
+		this.abort = new AbortController();
+		const listeners = [...this.listeners];
+		this.active = listeners.length > 0;
+		if (this.active) this.run(listeners, this.abort.signal);
+	}
+	async run(listeners, signal) {
+		const disconnected = (cause) => listeners.forEach((listener) => report(listener, cause));
+		let delay = 1e3;
+		while (!signal.aborted) {
+			try {
+				for await (const results of this.client.watch(listeners.map((item) => item.subscription), signal)) {
+					if (signal.aborted) break;
+					delay = 1e3;
+					listeners.forEach((listener, index) => {
+						const result = results[index];
+						if (result) this.deliver(listener, result);
+					});
+				}
+				if (!signal.aborted) disconnected(/* @__PURE__ */ new Error("Connection closed."));
+			} catch (error) {
+				if (!signal.aborted) disconnected(error);
+				if (error instanceof ReviewApiError && [
+					401,
+					403,
+					404
+				].includes(error.status)) return;
+			}
+			if (!signal.aborted) await sleep(delay, signal);
+			delay = Math.min(delay * 2, 3e4);
+		}
+	}
+	/** Renders never block the stream: a slow tab only delays its own newest state. */
+	deliver(listener, result) {
+		listener.queued = result;
+		if (listener.draining) return;
+		listener.draining = true;
+		(async () => {
+			while (listener.queued && !listener.signal.aborted) {
+				const next = listener.queued;
+				listener.queued = void 0;
+				if (next.error) {
+					report(listener, new Error(next.error));
+					continue;
+				}
+				try {
+					await listener.accept(next.value);
+				} catch (error) {
+					report(listener, error);
+					await sleep(retryDelayMs, listener.signal);
+					listener.queued ??= next;
+				}
+			}
+			listener.draining = false;
+		})();
+	}
+};
+//#endregion
+//#region src/review-api/agent-client.ts
+const TEXT_TOOLS = /* @__PURE__ */ new Set([
+	"review_get",
+	"review_get_instructions",
+	"session_get",
+	"session_get_instructions"
+]);
+async function connectReviewApi(env = process.env, headers = {}) {
+	return (await connectReviewInstance(env, headers)).client;
+}
+async function connectReviewInstance(env = process.env, headers = {}) {
+	const request = (url, init) => {
+		const merged = new Headers(init?.headers);
+		for (const [key, value] of Object.entries(headers)) merged.set(key, value);
+		return fetch(url, {
+			...init,
+			headers: merged
+		});
+	};
+	if (env.DEV_REVIEW_SERVER_DIR?.trim()) {
+		const stateDir = reviewServerStateDir(env);
+		const server = await readReviewServerDiscovery(stateDir);
+		if (!server || !await reviewServerIsHealthy(server)) throw serverNotReady(stateDir);
+		return { client: new ReviewApiClient({
+			serverUrl: server.url,
+			token: server.token
+		}, request) };
+	}
+	const selection = await selectReviewInstance({ env });
+	const discovery = healthyReviewInstance(selection);
+	if (!discovery) {
+		const unavailable = reviewInstanceUnavailable(selection);
+		const message = `${unavailable.message} For headless authoring, select a running server with --state-dir or DEV_REVIEW_SERVER_DIR.`;
+		if (unavailable instanceof ReviewInstanceUnavailableError) throw new ReviewInstanceUnavailableError(message);
+		throw unavailable;
+	}
+	return {
+		client: new ReviewApiClient({
+			serverUrl: discovery.url,
+			token: discovery.token
+		}, request),
+		instance: {
+			key: selection.key,
+			appVersion: discovery.appVersion
+		}
+	};
+}
+/** Only translate the tool envelope. The host owns validation and persistence. */
+async function callAuthoringTool(client, tool, input, signal) {
+	if (tool.commandType) try {
+		return await client.post(tool.path, { operation: {
+			...input,
+			type: tool.commandType
+		} }, signal);
+	} catch (error) {
+		if (error instanceof ReviewApiError || signal?.aborted) throw error;
+		throw new Error(`Whiteboard may or may not have applied ${tool.name} (${error instanceof Error ? error.message : String(error)}). Check with review_get before retrying.`, { cause: error });
+	}
+	const fields = { ...input };
+	const route = tool.path.replace(/:reviewId\b/g, () => {
+		const value = fields.reviewId;
+		if (!isStringValue(value) || !value) throw new ReviewInputError("reviewId is required.");
+		delete fields.reviewId;
+		return encodeURIComponent(value);
+	});
+	if (tool.method === "POST") return client.post(route, fields, signal);
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(fields)) {
+		if (value === null || value === void 0) continue;
+		for (const item of Array.isArray(value) ? value : [value]) {
+			if (!isStringValue(item) && !isNumberValue(item) && !isBooleanValue(item)) throw new ReviewInputError(`${key} must be a string, number, boolean or list of them.`);
+			query.append(key, String(item));
+		}
+	}
+	const response = await client.response(route + (query.size ? `?${query}` : ""), { signal });
+	return response.headers.get("content-type")?.startsWith("text/plain") ? new ToolText(await response.text()) : parseJsonText(await response.text());
+}
+/** A plain-text reply, shown to the agent as-is instead of as a JSON string. */
+var ToolText = class {
+	text;
+	constructor(text) {
+		this.text = text;
+	}
+};
+/** The text an agent sees for a tool result. */
+function toolResultText(tool, result) {
+	if (result instanceof ToolText) return result.text;
+	return TEXT_TOOLS.has(tool.name) && isStringValue(result) ? result : JSON.stringify(result);
+}
+//#endregion
+export { toolResultText as a, connectReviewInstance as i, callAuthoringTool as n, ReviewApiClient as o, connectReviewApi as r, ReviewApiError as s, ToolText as t };

package/dist/authoring-tools-Cr6Kpjsx.js

@@ -0,0 +1,234 @@
+import { g as activityUpdateSchema, h as activityEndSchema, i as commandSchema, m as activityBeginSchema, n as uploadSchema } from "./local-data-CxLk75rx.js";
+import { x as publishedEditSchema, y as pathTargetSchema } from "./stored-document-migration-DHeMpLMb.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { t as findReviewPackageRoot } from "./package-paths-B6-zxvIO.js";
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/review-api/read-schemas.ts
+const version = z.union([z.literal("").transform(() => void 0), z.coerce.number().int().nonnegative()]).optional();
+const commit = z.string().min(1).optional();
+const side = z.enum(["base", "head"]);
+/** Read at a reference's own pins instead of the review's target. Flat, so
+* the same shape serves query strings and tool inputs. */
+const anchor = {
+	repositoryId: z.string().min(1).optional(),
+	head: z.string().min(1).optional(),
+	base: z.string().min(1).optional()
+};
+function queryAnchor(input) {
+	if (!input.repositoryId && !input.head && !input.base) return void 0;
+	if (!input.repositoryId || !input.head) throw new ReviewInputError("Reading at explicit pins needs both repositoryId and head.");
+	const pins = {
+		repositoryId: input.repositoryId,
+		head: input.head
+	};
+	if (input.base) pins.base = input.base;
+	return pins;
+}
+const inspectQuerySchema = z.strictObject({
+	version,
+	targetId: z.string().min(1).optional(),
+	full: z.union([z.literal(true), z.literal("true")]).optional(),
+	format: z.enum(["text", "json"]).default("text")
+});
+const readQuerySchemas = {
+	get: z.strictObject({
+		version,
+		targetId: z.string().min(1).optional(),
+		full: z.union([z.literal(true), z.literal("true")]).optional()
+	}),
+	maps: z.strictObject({ version }),
+	tree: z.strictObject({
+		version,
+		commit,
+		...anchor,
+		side: side.default("head"),
+		path: z.string().default("")
+	}),
+	file: z.strictObject({
+		version,
+		commit,
+		...anchor,
+		side,
+		file: z.string().min(1)
+	}),
+	diff: z.strictObject({
+		version,
+		commit,
+		...anchor
+	}),
+	structuralDiff: z.strictObject({
+		version,
+		commit,
+		...anchor,
+		file: z.string().min(1).optional()
+	}),
+	commits: z.strictObject({ version })
+};
+//#endregion
+//#region src/review-api/component-reference.ts
+/** Every component's fields, for session_get_instructions: the edit tool's
+* description must stay short enough that clients don't cut it off. */
+const COMPONENT_REFERENCE = [
+	"## Components",
+	"",
+	"session_edit's content is one component, named by its type. Fields, with ? for optional and anchor for a source anchor string:",
+	"",
+	"- markdown {markdown, pins?}",
+	"- code {text, language?, caption?}",
+	"- divider {}",
+	"- code_peek {source: anchor, caption?, pins?}",
+	"- section {title, children: component[], defaultCollapsed?}",
+	"- callout {children: component[], title?, tone?: info|warning|danger|success}",
+	"- image {assetId from session_upload, alt, caption?}",
+	"- trace_quote {traceId, eventId, text}",
+	"- software_map {mapVersionId, focusElementId?}",
+	"- sequence {title, actors: {key: label}, steps: step[], pins?}",
+	"- step {from, to (actor keys), label, style?: call|return|async, and exactly one of source: anchor, explanation, or code: {text, language?}; pins?}",
+	"- flow_diagram {title, nodes: flow_node[] (1 to 100), edges: flow_edge[], description?, direction?: right|down, pins?}",
+	"- flow_node {key, label, description?, kind?: process|decision|terminal, attachments?: {label, sources: anchor[], pins?}[], link?: {from or to, label?, style?}}",
+	"- flow_edge {from, to (node keys), label?, style?: solid|dashed}",
+	"- call_stack_diff {title, base: frame[], head: frame[], pins?}; either side may be empty",
+	"- frame {source: anchor, label?, key?, parentKey? (an earlier frame on that side), callSite?: anchor, contextSources?: anchor[], via?: {kind: call|queue|callback|rpc, reason}, pins?}",
+	"- database_lens {title, actors: {key: label}, stores: {key: store}, useCases: useCase[] (1 or more), pins?}",
+	"- store {label, storage: relational|document, collections: {key: {label, fields: {key: field}}}, dataStoreKind?: database|objectStore|bucket|artifactStore|fileStore}",
+	"- field {label, dataType, nullable?, primaryKey?, references?: {store, collection, field}, fields?: {key: field}}",
+	"- useCase {label, summary?, operations: operation[] (1 or more)}; operation {kind: read|write, actor, store, collection, label, source: anchor, field?, detail?, pins?}, naming declared keys",
+	"",
+	"Example (replace its path and lines with verified ones): {\"type\":\"sequence\",\"title\":\"Request\",\"actors\":{\"a\":\"Client\",\"b\":\"Server\"},\"steps\":[{\"from\":\"a\",\"to\":\"b\",\"label\":\"Send\",\"source\":\"head/src/app.ts#L10-L20\"}]}"
+].join("\n");
+const instructionsQuerySchema = z.strictObject({ topic: z.enum([
+	"authoring",
+	"file-lenses",
+	"scratchpad",
+	"trace-archaeology"
+]).default("authoring") });
+function scratchpadAvailable(context) {
+	return context.desktopAvailable && context.scratchpadEnabled;
+}
+const cache = /* @__PURE__ */ new Map();
+function read(root, name) {
+	const file = path.join(root, "instructions", `${name}.md`);
+	let content = cache.get(file);
+	if (!content) {
+		content = readFile(file, "utf8").catch((error) => {
+			cache.delete(file);
+			throw error;
+		});
+		cache.set(file, content);
+	}
+	return content;
+}
+async function renderInstructions(topic, context, root = findReviewPackageRoot(import.meta.url)) {
+	if (topic === "scratchpad" && !scratchpadAvailable(context)) return "The Whiteboard scratchpad is turned off or Whiteboard Desktop is not running. Answer in chat; the scratchpad can be turned on in Whiteboard Desktop Settings.";
+	if (topic === "trace-archaeology" && !context.traceEnabled) return "Trace capture is off on this machine, so no agent traces are available. It can be turned on in Whiteboard Desktop Settings under Experimental Features.";
+	if (topic === "scratchpad") return `${await read(root, topic)}\n\n${COMPONENT_REFERENCE}`;
+	if (topic !== "authoring") return read(root, topic);
+	const more = [...scratchpadAvailable(context) ? ["- Explaining code visually outside a review: `session_get_instructions({topic:\"scratchpad\"})`"] : [], ...context.traceEnabled ? ["- Why code exists / past agent sessions: `session_get_instructions({topic:\"trace-archaeology\"})`"] : []];
+	return [
+		await read(root, "authoring"),
+		COMPONENT_REFERENCE,
+		...context.traceEnabled ? ["## Traces\n\nAt the end, run `whiteboard trace list --session <sessionId> --json`, which covers every commit in the review. If it lists no sessions, there are no traces to quote: skip this step. Otherwise read `session_get_instructions({topic:\"trace-archaeology\"})` and rewrite as much as possible of the what/why, design, and requirements sections in terms of literal trace quotes from the user."] : [],
+		...more.length ? [`## More guidance\n\n${more.join("\n")}`] : []
+	].join("\n\n");
+}
+//#endregion
+//#region src/review-api/status-tool.ts
+/** Listed by the MCP adapter even while no Desktop is reachable. Its public
+* name is kept: it names the app instance, not a session. */
+const REVIEW_STATUS_TOOL = {
+	name: "whiteboard_status",
+	description: "Name the Whiteboard instance this session talks to: key (stable, preview or dev-<checkout>), channel, checkout, appVersion, cliVersion, instanceId, url, home and desktopAvailable. Call it before changing anything when the user mentions Preview, a checkout or a dev build.",
+	inputSchema: {
+		type: "object",
+		properties: {}
+	},
+	method: "GET",
+	path: "/status"
+};
+//#endregion
+//#region src/review-api/authoring-tools.ts
+/** The host publishes its input schemas, except where agents write less than
+* the host accepts (publishedEditSchema, publishedLensEditSchema) or name a
+* checkout by path (pathTargetSchema); adapters validate nothing. */
+function authoringTools(scratchpadAvailable = false, traceEnabled = false) {
+	const id = z.string().min(1);
+	const review = { reviewId: id };
+	const [image, trace] = uploadSchema.options;
+	const uploadInput = z.strictObject({
+		...image.shape,
+		...trace.shape,
+		kind: z.enum(["image", "trace"])
+	}).partial().required({
+		id: true,
+		repositoryId: true,
+		kind: true
+	});
+	const descriptions = {
+		create: "Create a review of saved working files, immutable commits or a GitHub PR. Revisions are resolved on acceptance. A worktree target reviews the saved files in its checkout, uncommitted ones included and untracked ones left out (git add -N a new file to include it), against base: the branch to compare against, by default the default branch of the repository. The diff starts at the merge base of base and HEAD, which follows rebases. Omitted commits base means source at head with no diff; supply the parent to review introduced changes. For a GitHub PR, pullRequestUrl alone is enough: target and title become optional, and the host fetches the PR into a registered checkout of its repository and pins the current PR head and GitHub diff base, titled from the PR. When a review for that PR exists, it is returned instead, reporting whether its head moved and whether an agent is working on it; update it in place, move its target with review_set_target, or create a separate review with reuseExisting. kind:\"scratchpad\" names the one scratchpad, which the host creates itself. The result carries review, the review as review_list shows it: its target with resolved commits, origin (its PR), repositoryName and repositoryPath, so no follow-up read is needed before diffing. When Desktop is available the review opens there and the result reports opened, softwareMapEnabled and environmentIssues, as review_open does; set open:false to author in the background without taking over Desktop.",
+		set_target: "Move the review to a new target, such as the commits after a rebase or amend, preserving the document and component IDs. Revisions are resolved on acceptance. Returns warnings for retained source ranges in files the new commits changed, to verify, and resources that no longer match; fix them with review_edit. Earlier versions keep their source. Omitted pullRequestUrl keeps the PR within the same repository; changing repositories clears it. Supply a URL to replace it or null to detach.",
+		edit: [
+			"Edit one document component. content is one component, named by its type; each type's fields are in the Components section of session_get_instructions (authoring or scratchpad).",
+			"Anchors are head/path#L10-L20 or base/path#L7, or diff/path#L84-R90 for a range across sides, with repository-relative paths and 1-based inclusive lines. pins {repositoryId, head, base?} say which commits anchors quote: a step, frame, attachment or operation without pins uses its block's, and a block without them the review's.",
+			"insert adds content: parentId nests it, afterId places it, and omitted placement appends (on the scratchpad, it lands at the top). update patches a component's own fields; null removes an optional one. A section's children and a diagram's units change through their own IDs; a call stack's frames change by replacing the call stack. move and remove take a targetId; removing a flow_node removes its edges.",
+			"The host assigns short durable IDs. The result names the edited component and, for an insert or replace, its first-level children, and quotes the first and last line of each anchor the edit added or changed (the first 20; unquotedAnchors counts the rest): check they are the lines you meant. Accepted edits save at once.",
+			"While a reader may be watching, write small and often: one paragraph per edit. Insert a new diagram whole. Change one already drawn a unit at a time (a flow_node, flow_edge or step, with parentId naming the diagram), and link each added flow_node to a node already drawn."
+		].join("\n"),
+		lens_edit: "Edit one Diff-view lens. Lenses partition the review's change for the Diff view; they sit beside the document (never in it) and version with it. The host assigns durable lens IDs; updates replace only the fields supplied. Write one lens per call while a reader may be watching; each draws in on the Diffs page. Pass your activityId so your courier draws each lens. The result identifies the lens and reports uncategorized: changed lines no lens selects yet, grouped by file. Keep adding lenses until it is empty or what remains is deliberate. review_lens_get reads the current lenses and gaps.",
+		rename: "Change the review title.",
+		restore: "Restore title, source pins, PR identity and content from a saved version.",
+		attention: "Mark a review viewed, dismissed or restored without changing its content.",
+		delete: "Permanently delete this review and its history."
+	};
+	const tool = (name, description, schema, method, path, commandType) => ({
+		name: `review_${name}`,
+		description,
+		inputSchema: {
+			...z.toJSONSchema(schema, { io: "input" }),
+			type: "object"
+		},
+		method,
+		path,
+		commandType
+	});
+	return [
+		REVIEW_STATUS_TOOL,
+		tool("capabilities", "Discover whether Desktop is available and optional software-map generation is enabled. Read before authoring.", z.strictObject({}), "GET", "/capabilities"),
+		tool("get_instructions", "Read Whiteboard's guidance before creating or editing a review. The default topic gives the authoring workflow; \"file-lenses\" covers Diff-view file lenses." + (traceEnabled ? " Call review_get_instructions({topic:\"trace-archaeology\"}) for why code exists, what an agent was thinking, or whether an agent solved this before." : "") + (scratchpadAvailable ? " When the user asks in conversation to be shown how code works or wants a diagram, without asking for a review, draw it on the scratchpad rather than answering only in chat: call review_get_instructions({topic:\"scratchpad\"}) first. A request for a review or to use Whiteboard means authoring a review with the default topic." : ""), instructionsQuerySchema.partial(), "GET", "/instructions"),
+		tool("activity_begin", "Show that you are working on a review: the reader sees your focus and your courier drawing your edits, and the review reads as finished only once every agent has ended. Returns an activityId: pass it to session_edit and session_lens_edit so your courier draws them, and to review_activity_update and review_activity_end. Nothing is locked; other agents can work on the review too. The activity expires after 3 minutes without an edit or update.", activityBeginSchema.extend(review), "POST", "/:reviewId/activity/begin"),
+		tool("activity_update", "Change your focus, or keep your activity alive during long reads or pauses; an edit carrying your activityId already keeps it alive. Omitted focus preserves it and null clears it. Fails once the activity has expired: begin a new one.", activityUpdateSchema.extend(review), "POST", "/:reviewId/activity/update"),
+		tool("activity_end", "End your activity when your part is finished: readers treat a review with content and no live activity as ready. Ending it creates no document version. Ending twice, or an expired activity, changes nothing.", activityEndSchema.extend(review), "POST", "/:reviewId/activity/end"),
+		...commandSchema.shape.operation.options.map((operation) => {
+			const type = operation.shape.type.value;
+			const { type: _type, repositoryId: _repositoryId, ...fields } = operation.shape;
+			return tool(type, descriptions[type], z.strictObject({
+				...fields,
+				...type === "create" && {
+					target: pathTargetSchema.optional(),
+					repositoryPath: id.optional().describe("Only with pullRequestUrl and no target: the local checkout to fetch the PR into. Default: the existing review's, else the first registered checkout with a remote for the PR's repository."),
+					open: z.boolean().optional()
+				},
+				...type === "set_target" && { target: pathTargetSchema },
+				...type === "edit" && { edit: publishedEditSchema }
+			}), "POST", "/commands", type);
+		}),
+		tool("list", "List saved reviews.", z.strictObject({}), "GET", ""),
+		tool("get", "Read a readable, nested text outline with editable IDs. targetId reads one component in full; full:true reads all content. Use format:json for raw node data or snapshots instead of text.", z.strictObject({
+			...review,
+			...inspectQuerySchema.shape
+		}), "GET", "/:reviewId/inspect"),
+		tool("lens_get", "Read the review's Diff-view lenses as authored (ids, titles, targets), each lens's resolved fileCount (and unavailable reason, if any), and uncategorized: the changed lines no lens selects yet, by file.", z.strictObject(review), "GET", "/:reviewId/lenses"),
+		tool("history", "List saved document versions.", z.strictObject(review), "GET", "/:reviewId/history"),
+		tool("open", "Show an existing review immediately and prepare current pinned checkouts in the background. Returns softwareMapEnabled and any already-recorded environmentIssues. Missing optional setup is not an issue; use review_environment to recheck.", z.strictObject(review), "POST", "/:reviewId/open"),
+		tool("environment", "Acquire and recheck this review's current base/head language checkouts (not historical or selected commits). Returns acquisition issues, not full LSP health. Missing optional setup and failed setup with a usable checkout stay silent. Set retry:true to rerun failed preparation after an actual language-feature failure; preparation runs in the background.", z.strictObject({
+			...review,
+			retry: z.boolean().optional()
+		}), "POST", "/:reviewId/environment"),
+		tool("workspace_cleanup", "Inspect failed cleanup of retired review-owned checkouts. Supply workspaceId to retry removal of that checkout. This does not remove active review checkouts.", z.strictObject({ workspaceId: id.optional() }), "POST", "/workspace-cleanup"),
+		tool("register_repository", "Register a local Git or jj repository and return its id, for pins on scratchpad blocks. session_create and session_set_target take the checkout's path instead.", z.strictObject({ path: id }), "POST", "/repositories"),
+		tool("upload", "Retain an image or trace for use in a review. kind:\"image\" takes base64; kind:\"trace\" takes trace. Reusing an upload ID requires identical content; rejected uploads are not saved.", uploadInput, "POST", "/resources")
+	];
+}
+//#endregion
+export { scratchpadAvailable as a, readQuerySchemas as c, renderInstructions as i, REVIEW_STATUS_TOOL as n, inspectQuerySchema as o, instructionsQuerySchema as r, queryAnchor as s, authoringTools as t };

package/dist/build-info.json

@@ -0,0 +1 @@
+{"version":"0.2.0","commit":"2c6b8b5b8fe7c3435cf223f6a12a87e507ccf6f1","dirty":true,"builtAt":"2026-10-05T19:58:31.957Z"}