@krapht/ork 0.2.0 → 0.3.0

package/dist/src-D5ruZFgD.mjs

@@ -0,0 +1,1973 @@
+import { B as requestContinue, F as linkNodes, H as requestStop, Kt as loadAgents, Nt as readCondition, Qt as placeFor, R as unlinkNodes, Sn as NodeSchema, U as tellLiveRun, V as requestPause, X as detachResume, Z as resumable, Zt as placeFiles, at as processAlive, bn as expandEdge, cn as skillsIn, ct as checkWorkflowText, d as triggersReport, dn as newWorkflowText, en as runDirOf, fn as readDocument, it as pausedOf, ln as WorkflowEditSchema, lt as walkChecks, mn as parseWorkflow, nn as workflowDirOf, nt as followEvents, o as limitsReport, ot as runStatus, pn as renderJsonSchema, r as capsHere, rn as inside, rt as liveStatus, st as runTree, tt as detachRun, un as applyEdits, ut as walkSummary, vn as EdgeInputSchema, yt as nodeSays } from "./src-Cz1yOUTg.mjs";
+import { a as pendingDecisions, i as answerDecision, r as nodeSession } from "./__build_info__-CXXMLvjt.mjs";
+import { n as newRunId, t as findRun } from "./find-BcvhT6UN.mjs";
+import { c as openStore, l as storePath, s as nodeOf } from "./output-Q2EdeVUt.mjs";
+import { n as usageReport } from "./report-DK4LGqwF.mjs";
+import path from "node:path";
+import { z } from "zod";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { homedir } from "node:os";
+import { createServer } from "node:http";
+// ../core/src/store/activity.ts
+const LONGEST_LINE = 120;
+/**
+* The fields of a tool's input that say what it's working on, best first. Only
+* these are shown, so what else a tool was given stays in the logs.
+*/
+const TARGETS = [
+	"file_path",
+	"notebook_path",
+	"path",
+	"url",
+	"pattern",
+	"query",
+	"command"
+];
+const oneLine = (text) => {
+	const line = text.replaceAll(/\s+/gu, " ").trim();
+	return line.length > LONGEST_LINE ? `${line.slice(0, 119)}…` : line;
+};
+const toolLine = ({ name, input }) => {
+	const target = TARGETS.map((field) => input[field]).find((value) => typeof value === "string" && value.trim() !== "");
+	if (typeof target !== "string") return name;
+	return oneLine(target.startsWith(`${name} `) ? target : `${name} ${target}`);
+};
+/** What a finished node said, or why it failed. */
+const finishedNow = (ok, error, summary) => {
+	if (!ok) return error === void 0 ? void 0 : oneLine(error);
+	return typeof summary === "string" && summary.trim() !== "" ? oneLine(summary) : void 0;
+};
+/** Each node's activity, by id; a node that never started has none. */
+const runActivity = (stored) => {
+	const nodes = /* @__PURE__ */ new Map();
+	const of = (id) => {
+		const found = nodes.get(id);
+		if (found !== void 0) return found;
+		const fresh = {};
+		nodes.set(id, fresh);
+		return fresh;
+	};
+	for (const { at, event } of stored) if (event.type === "node.started") {
+		const node = of(event.id);
+		node.startedAt ??= at;
+		delete node.finishedAt;
+		delete node.now;
+	} else if (event.type === "node.event") {
+		if (event.event.type === "tool.called") of(event.id).now = toolLine(event.event);
+	} else if (event.type === "decision.opened") of(event.node).now = oneLine(`Asked: ${event.question}`);
+	else if (event.type === "decision.answered") of(event.node).now = oneLine(`Answered: ${event.answer}`);
+	else if (event.type === "decision.withdrawn") delete of(event.node).now;
+	else if (event.type === "node.finished") {
+		const node = of(event.id);
+		node.finishedAt = at;
+		const now = finishedNow(event.ok, event.error, event.output["summary"]);
+		if (now === void 0) delete node.now;
+		else node.now = now;
+	}
+	return nodes;
+};
+/** The ownership tree, with what each node is doing and when it ran. */
+const activeTree = (stored) => {
+	const activity = runActivity(stored);
+	const dress = (node) => {
+		Object.assign(node, activity.get(node.id));
+		for (const child of node.children) dress(child);
+	};
+	const roots = runTree(stored.map(({ event }) => event));
+	for (const root of roots) dress(root);
+	return roots;
+};
+// ../server/src/contract-builder.ts
+/** A new workflow's name, as its file and its `name:` take it. */
+const NewWorkflowSchema = z.strictObject({ name: z.string().min(1) });
+/** The server checks each edit; this file imports only types of the schema. */
+const WorkflowEditsSchema = z.strictObject({ edits: z.array(z.custom()).min(1) });
+/** Earlier text, and the file it was based on, to ask before replacing it. */
+const DraftTextSchema = z.strictObject({
+	text: z.string(),
+	baseHash: z.string().nullable()
+});
+const SaveWorkflowSchema = z.strictObject({ 
+/** Write over a file that changed since this draft began. */
+force: z.boolean().optional() });
+const BUILDER_API = {
+	builderSchema: {
+		method: "GET",
+		path: "/api/workflow-schema"
+	},
+	builderCatalog: {
+		method: "GET",
+		path: "/api/projects/:id/catalog"
+	},
+	builderDrafts: {
+		method: "GET",
+		path: "/api/projects/:id/builder"
+	},
+	builderView: {
+		method: "GET",
+		path: "/api/projects/:id/builder/:name"
+	},
+	builderCreate: {
+		method: "POST",
+		path: "/api/projects/:id/builder",
+		body: NewWorkflowSchema
+	},
+	builderEdit: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/edits",
+		body: WorkflowEditsSchema
+	},
+	builderRestore: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/text",
+		body: DraftTextSchema
+	},
+	builderDiscard: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/discard"
+	},
+	builderSave: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/save",
+		body: SaveWorkflowSchema
+	}
+};
+// ../server/src/contract.ts
+const Count = z.coerce.number().int().positive();
+const Seq = z.coerce.number().int().nonnegative();
+const Driver = z.enum(["sdk", "cli"]);
+const RunsQuerySchema = z.strictObject({
+	project: z.string().min(1).optional(),
+	limit: Count.optional()
+});
+const UsageQuerySchema = z.strictObject({
+	project: z.string().min(1).optional(),
+	workflow: z.string().min(1).optional(),
+	/** ISO times: `since` included, `until` not. */
+	since: z.iso.datetime().optional(),
+	until: z.iso.datetime().optional()
+});
+const EventsQuerySchema = z.strictObject({
+	after: Seq.optional(),
+	node: z.string().min(1).optional(),
+	/** Only the first this many. */
+	limit: Count.optional(),
+	/** Only the newest this many, still oldest first. */
+	last: Count.optional()
+});
+const DecisionsQuerySchema = z.strictObject({
+	run: z.string().min(1).optional(),
+	project: z.string().min(1).optional()
+});
+const AnswerSchema = z.strictObject({ choose: z.string().min(1) });
+const RunFlags = {
+	inputs: z.record(z.string(), z.string()).optional(),
+	driver: Driver.optional(),
+	inPlace: z.boolean().optional(),
+	allowDirty: z.boolean().optional()
+};
+const StartRunSchema = z.strictObject({
+	/** A registered project's id or root. */
+	project: z.string().min(1),
+	/** A workflow's name in the project, or a path inside the project. */
+	workflow: z.string().min(1),
+	...RunFlags
+});
+const ResumeRunSchema = z.strictObject(RunFlags);
+const MessageSchema = z.strictObject({
+	node: z.string().min(1),
+	body: z.string().min(1)
+});
+/** Two nodes of live runs, each `<run>/<node>` (RFC-003). */
+const LinkSchema = z.strictObject({
+	a: z.string().min(3),
+	b: z.string().min(3),
+	maxMessages: z.number().int().positive().optional()
+});
+const UnlinkSchema = z.strictObject({
+	a: z.string().min(3),
+	b: z.string().min(3)
+});
+const LinksQuerySchema = z.strictObject({ run: z.string().min(1).optional() });
+/** Pause, continue or stop: the whole run, or `node` alone (ADR-041). */
+const ControlSchema = z.strictObject({ node: z.string().min(1).optional() });
+/** Every JSON route; the two event streams are in {@link STREAMS}. */
+const API = {
+	health: {
+		method: "GET",
+		path: "/api/health"
+	},
+	...BUILDER_API,
+	projects: {
+		method: "GET",
+		path: "/api/projects"
+	},
+	workflows: {
+		method: "GET",
+		path: "/api/projects/:id/workflows"
+	},
+	runs: {
+		method: "GET",
+		path: "/api/runs",
+		query: RunsQuerySchema
+	},
+	run: {
+		method: "GET",
+		path: "/api/runs/:id"
+	},
+	tree: {
+		method: "GET",
+		path: "/api/runs/:id/tree"
+	},
+	graph: {
+		method: "GET",
+		path: "/api/runs/:id/graph"
+	},
+	events: {
+		method: "GET",
+		path: "/api/runs/:id/events",
+		query: EventsQuerySchema
+	},
+	decisions: {
+		method: "GET",
+		path: "/api/decisions",
+		query: DecisionsQuerySchema
+	},
+	decision: {
+		method: "GET",
+		path: "/api/decisions/:id"
+	},
+	answer: {
+		method: "POST",
+		path: "/api/decisions/:id",
+		body: AnswerSchema
+	},
+	start: {
+		method: "POST",
+		path: "/api/runs",
+		body: StartRunSchema
+	},
+	resume: {
+		method: "POST",
+		path: "/api/runs/:id/resume",
+		body: ResumeRunSchema
+	},
+	stop: {
+		method: "POST",
+		path: "/api/runs/:id/stop",
+		body: ControlSchema
+	},
+	pause: {
+		method: "POST",
+		path: "/api/runs/:id/pause",
+		body: ControlSchema
+	},
+	continue: {
+		method: "POST",
+		path: "/api/runs/:id/continue",
+		body: ControlSchema
+	},
+	message: {
+		method: "POST",
+		path: "/api/runs/:id/messages",
+		body: MessageSchema
+	},
+	usage: {
+		method: "GET",
+		path: "/api/usage",
+		query: UsageQuerySchema
+	},
+	triggers: {
+		method: "GET",
+		path: "/api/triggers"
+	},
+	links: {
+		method: "GET",
+		path: "/api/links",
+		query: LinksQuerySchema
+	},
+	link: {
+		method: "POST",
+		path: "/api/links",
+		body: LinkSchema
+	},
+	unlink: {
+		method: "POST",
+		path: "/api/links/end",
+		body: UnlinkSchema
+	}
+};
+/** The Server-Sent Event streams, and the events each sends. */
+const STREAMS = {
+	/**
+	* `run-event` per stored event (`id:` is its seq), then `end`. Starts after
+	* `Last-Event-ID`, or `?after=`.
+	*/
+	run: "/api/runs/:id/stream",
+	/** `runs` and `decisions`, each when it changes; `?project=` keeps one. */
+	overview: "/api/stream"
+};
+// ../server/src/graph.ts
+/**
+* @file A workflow or a run as the graph the UI draws: its nodes, its edges
+*   with their shorthand expanded, and its channels. Where they sit follows
+*   from those, so nothing about that is stored (RFC-008).
+*/
+const workflowGraph = (workflow) => ({
+	nodes: Object.entries(workflow.nodes).map(([id, node]) => ({
+		id,
+		type: node.type,
+		parent: node.parent
+	})),
+	edges: (workflow.edges ?? []).flatMap((input, index) => {
+		const expanded = expandEdge(input, index);
+		return expanded.ok ? expanded.edges.map(({ from, to, when, maxRounds }) => ({
+			from,
+			to,
+			when,
+			maxRounds
+		})) : [];
+	}),
+	channels: (workflow.messages ?? []).map(({ between: [a, b] }) => [a, b])
+});
+/** The graph of a workflow file, or `null` if it is gone or does not parse. */
+const readWorkflowGraph = (file) => {
+	if (!existsSync(file)) return null;
+	const parsed = parseWorkflow(readFileSync(file, "utf8"));
+	if (!parsed.ok) return null;
+	return workflowGraph(parsed.workflow);
+};
+/**
+* The graph of a run: what it recorded it ran, so editing the file later does
+* not redraw it. A run from before edges were kept has only its file to go by.
+*/
+const runGraph = (events, file) => {
+	const started = events.findLast((event) => event.type === "run.started");
+	const onFile = readWorkflowGraph(file);
+	const nodes = started?.type === "run.started" ? started.nodes : [];
+	const edges = started?.type === "run.started" ? started.edges : void 0;
+	const channels = started?.type === "run.started" ? started.channels : void 0;
+	return {
+		nodes: nodes.length === 0 ? onFile?.nodes ?? [] : nodes.map(({ id, type, parent }) => ({
+			id,
+			type,
+			parent
+		})),
+		edges: edges ?? onFile?.edges ?? [],
+		channels: channels ?? onFile?.channels ?? [],
+		...started?.type === "run.started" && started.budgetUsd !== void 0 ? { budgetUsd: started.budgetUsd } : {}
+	};
+};
+// ../server/src/guards.ts
+/**
+* @file What the server lets in (ADR-039, specs/server.md#security): only its
+*   own loopback `Host` (against DNS rebinding); only with its token, from the
+*   session cookie or an `Authorization: Bearer` header; and, for a write sent
+*   with the cookie, only from its own `Origin` (against CSRF). The token in
+*   `?token=` is swapped once for the cookie, with a redirect that takes it out
+*   of the address bar. Pure: it reads the request's parts and decides.
+*/
+const WRITES = /* @__PURE__ */ new Set([
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+/** A new token: 32 random bytes. */
+const newToken = () => randomBytes(32).toString("base64url");
+/** The session cookie's name; one per port, as cookies ignore ports. */
+const cookieName = (port) => `ork_ui_${String(port)}`;
+/** Whether `given` is the token, compared in constant time. */
+const sameToken = (given, token) => {
+	const a = Buffer.from(given);
+	const b = Buffer.from(token);
+	return a.length === b.length && timingSafeEqual(a, b);
+};
+const header = (request, name) => {
+	const value = request.headers[name];
+	return Array.isArray(value) ? value[0] : value;
+};
+/** The server's own origins: `127.0.0.1` and `localhost` on its port. */
+const ownOrigins = (port) => [`http://127.0.0.1:${String(port)}`, `http://localhost:${String(port)}`];
+const cookieValue = (request, name) => (header(request, "cookie") ?? "").split(";").map((part) => part.trim().split("=")).find(([key]) => key === name)?.slice(1).join("=");
+const bearer = (request) => {
+	return /^Bearer\s+(\S+)$/iu.exec(header(request, "authorization") ?? "")?.[1];
+};
+/** The session cookie that holds `token`. */
+const sessionCookie = (port, token) => `${cookieName(port)}=${token}; HttpOnly; SameSite=Strict; Path=/`;
+const exchange = (request, context) => {
+	const url = new URL(request.url, "http://127.0.0.1");
+	const given = url.searchParams.get("token");
+	if (given === null || request.method !== "GET") return null;
+	if (!sameToken(given, context.token)) return {
+		kind: "refuse",
+		status: 401,
+		error: "That link's token is not this server's; open it again with `ork ui`."
+	};
+	url.searchParams.delete("token");
+	return {
+		kind: "exchange",
+		cookie: sessionCookie(context.port, context.token),
+		location: `${url.pathname}${url.search}`
+	};
+};
+/** Decides whether a request may go on. */
+const guard = (request, context) => {
+	const host = header(request, "host") ?? "";
+	if (!ownOrigins(context.port).includes(`http://${host}`)) return {
+		kind: "refuse",
+		status: 403,
+		error: `Host ${host} is not this server.`
+	};
+	const exchanged = exchange(request, context);
+	if (exchanged !== null) return exchanged;
+	const fromBearer = bearer(request);
+	const fromCookie = cookieValue(request, cookieName(context.port));
+	const given = fromBearer ?? fromCookie;
+	if (given === void 0 || !sameToken(given, context.token)) return {
+		kind: "refuse",
+		status: 401,
+		error: "Not signed in; open the UI with `ork ui`."
+	};
+	if (!WRITES.has(request.method)) return { kind: "pass" };
+	const origin = header(request, "origin");
+	if ((fromBearer === void 0 || origin !== void 0) && (origin === void 0 || !ownOrigins(context.port).includes(origin))) return {
+		kind: "refuse",
+		status: 403,
+		error: `Origin ${origin ?? "(none)"} may not write here.`
+	};
+	const type = header(request, "content-type") ?? "";
+	if (!/^application\/json\s*(;|$)/iu.test(type)) return {
+		kind: "refuse",
+		status: 415,
+		error: "Send JSON (Content-Type: application/json)."
+	};
+	return { kind: "pass" };
+};
+/** How often an open event stream gets a keep-alive comment. */
+const KEEP_ALIVE_MS = 15e3;
+/** Sent with every answer: no sniffing, no framing, no referrer, no cache. */
+const BASE_HEADERS = {
+	"x-content-type-options": "nosniff",
+	"x-frame-options": "DENY",
+	"referrer-policy": "no-referrer",
+	"cache-control": "no-store"
+};
+const sendJson = (res, status, body, headers = {}) => {
+	res.writeHead(status, {
+		...BASE_HEADERS,
+		...headers,
+		"content-type": "application/json; charset=utf-8"
+	}).end(JSON.stringify(body));
+};
+const sendError = (res, status, error) => {
+	sendJson(res, status, { error });
+};
+/** Reads a JSON body; an empty body reads as `{}`. */
+const readJson = async (req) => {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		size += buffer.length;
+		if (size > 1048576) return {
+			ok: false,
+			status: 413,
+			error: "The body is too large."
+		};
+		chunks.push(buffer);
+	}
+	const text = Buffer.concat(chunks).toString("utf8").trim();
+	if (text === "") return {
+		ok: true,
+		value: {}
+	};
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(text)
+		};
+	} catch {
+		return {
+			ok: false,
+			status: 400,
+			error: "The body is not valid JSON."
+		};
+	}
+};
+/** Opens a Server-Sent Event stream on `res`. */
+const openEventStream = (res, keepAliveMs = KEEP_ALIVE_MS) => {
+	const abort = new AbortController();
+	res.writeHead(200, {
+		...BASE_HEADERS,
+		"content-type": "text/event-stream; charset=utf-8",
+		connection: "keep-alive"
+	});
+	res.write("retry: 1000\n\n");
+	const timer = setInterval(() => {
+		res.write(": keep-alive\n\n");
+	}, keepAliveMs);
+	const close = () => {
+		if (abort.signal.aborted) return;
+		clearInterval(timer);
+		abort.abort();
+		res.end();
+	};
+	res.on("close", close);
+	return {
+		send: (event, data, id) => {
+			if (abort.signal.aborted) return;
+			const head = id === void 0 ? "" : `id: ${String(id)}\n`;
+			res.write(`${head}event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+		},
+		close,
+		signal: abort.signal
+	};
+};
+// ../server/src/router.ts
+const ok = (body) => ({
+	status: 200,
+	body
+});
+const accepted = (body) => ({
+	status: 202,
+	body
+});
+const fail = (status, error) => ({
+	status,
+	error
+});
+/** A path such as `/api/runs/:id` as a pattern with its param names. */
+const compilePath = (path) => {
+	const keys = [];
+	const source = path.replaceAll(/:(\w+)/gu, (_, key) => {
+		keys.push(key);
+		return "([^/]+)";
+	});
+	return {
+		pattern: new RegExp(`^${source}$`, "u"),
+		keys
+	};
+};
+const isRouteName = (name) => name in API;
+const compile = (name) => {
+	const spec = API[name];
+	const { pattern, keys } = compilePath(spec.path);
+	const compiled = {
+		name,
+		method: spec.method,
+		pattern,
+		keys
+	};
+	if (spec.query !== void 0) compiled.query = spec.query;
+	if (spec.body !== void 0) compiled.body = spec.body;
+	return compiled;
+};
+const ROUTES = Object.keys(API).filter((name) => isRouteName(name)).map((name) => compile(name));
+const issues = (error) => error.issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join("; ");
+const parse = (schema, value) => {
+	if (schema === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	const parsed = schema.safeParse(value);
+	return parsed.success ? {
+		ok: true,
+		value: parsed.data
+	} : {
+		ok: false,
+		error: issues(parsed.error)
+	};
+};
+const decode = (value) => {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return null;
+	}
+};
+/**
+* Answers the request if a JSON route has its path, and returns whether one
+* did; a path with no route for the method gets 405.
+*/
+const route = async (handlers, req, res, url) => {
+	const found = ROUTES.map((r) => ({
+		r,
+		m: r.pattern.exec(url.pathname)
+	})).filter(({ m }) => m !== null);
+	if (found.length === 0) return false;
+	const hit = found.find(({ r }) => r.method === req.method);
+	if (hit === void 0 || hit.m === null) {
+		sendError(res, 405, `${req.method ?? ""} is not allowed here.`);
+		return true;
+	}
+	const { r, m } = hit;
+	const params = {};
+	for (const [i, key] of r.keys.entries()) {
+		const value = decode(m[i + 1] ?? "");
+		if (value === null) {
+			sendError(res, 400, `The ${key} in the path is not valid.`);
+			return true;
+		}
+		params[key] = value;
+	}
+	const query = parse(r.query, Object.fromEntries(url.searchParams));
+	if (!query.ok) {
+		sendError(res, 400, query.error);
+		return true;
+	}
+	const read = req.method === "GET" ? {
+		ok: true,
+		value: void 0
+	} : await readJson(req);
+	if (!read.ok) {
+		sendError(res, read.status, read.error);
+		return true;
+	}
+	const body = parse(r.body, read.value);
+	if (!body.ok) {
+		sendError(res, 400, body.error);
+		return true;
+	}
+	const handler = handlers[r.name];
+	const reply = await handler({
+		params,
+		query: query.value,
+		body: body.value
+	});
+	if ("error" in reply) sendError(res, reply.status, reply.error);
+	else sendJson(res, reply.status, reply.body);
+	return true;
+};
+// ../server/src/context.ts
+/**
+* @file What the server's handlers share: the store it reads and writes, where
+*   the sockets are, the `ork` script that detached runs start from, and how a
+*   request names a run or a project.
+*/
+/** A run by id or unique prefix: 404 when there is none, 400 when several. */
+const runOf = (context, id) => {
+	const found = findRun(context.store, id, "");
+	if (found.ok) return found;
+	const status = context.store.lookup(id).length === 0 ? 404 : 400;
+	return {
+		ok: false,
+		refusal: fail(status, found.error)
+	};
+};
+/** A registered project by id or root. */
+const projectOf = (context, key) => context.store.projects().find((p) => p.id === key || p.root === key);
+/** A run as the API shows it: with its live status and what is paused. */
+const viewOf$2 = (context, run) => {
+	const events = run.status === "running" ? context.store.events(run.id).map((stored) => stored.event) : [];
+	return {
+		...run,
+		live: runStatus(run, events),
+		paused: pausedOf(events)
+	};
+};
+// ../server/src/mcp-answers.ts
+/**
+* @file What `ork mcp`'s tools answer with (RFC-012): a route's reply as text,
+*   with long strings cut so one answer can't fill a model's context, and the
+*   workflow format a part at a time, as the whole is about 50 KB.
+*/
+/** How long a string can be before an answer cuts it. */
+const LONGEST = 400;
+/** A value with every long string cut, saying how much was left out. */
+const shrink = (value, longest = LONGEST) => {
+	if (typeof value === "string") return value.length <= longest ? value : `${value.slice(0, longest)}… (${String(value.length - longest)} more characters)`;
+	if (Array.isArray(value)) return value.map((item) => shrink(item, longest));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, shrink(item, longest)]));
+	return value;
+};
+const answer = (value) => ({ text: JSON.stringify(shrink(value)) });
+const refused = (error) => ({
+	text: error,
+	isError: true
+});
+/** A route's reply as an answer, `then` shaping what it gave. */
+const fromReply = async (reply, then = (body) => body) => {
+	const settled = await reply;
+	return "error" in settled ? refused(settled.error) : answer(then(settled.body));
+};
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A field of an object, or `undefined`. */
+const at = (value, key) => isRecord$1(value) ? value[key] : void 0;
+/** A node type's name, from its branch of the schema. */
+const typeOf = (branch) => {
+	const type = at(at(at(branch, "properties"), "type"), "const");
+	return typeof type === "string" ? type : void 0;
+};
+/**
+* The format's JSON Schema: with no node type, the workflow's own fields and
+* the node types there are; with one, that type's full schema.
+*/
+const formatPart = (nodeType) => {
+	const schema = JSON.parse(renderJsonSchema());
+	const oneOf = at(at(at(at(schema, "properties"), "nodes"), "additionalProperties"), "oneOf");
+	const branches = Array.isArray(oneOf) ? oneOf : [];
+	const types = branches.flatMap((branch) => typeOf(branch) ?? []);
+	const properties = at(schema, "properties");
+	if (nodeType === void 0) return answer({
+		...isRecord$1(schema) ? schema : {},
+		properties: {
+			...isRecord$1(properties) ? properties : {},
+			nodes: {
+				description: "A map of node ids to nodes. Ask for one node type to see its fields.",
+				nodeTypes: types
+			}
+		}
+	});
+	const branch = branches.find((item) => typeOf(item) === nodeType);
+	return branch === void 0 ? refused(`No node type \`${nodeType}\`. The types are: ${types.map((type) => `\`${type}\``).join(", ")}.`) : { text: JSON.stringify(branch) };
+};
+// ../server/src/mcp-tool.ts
+/**
+* @file One of `ork mcp`'s tools (RFC-012): its name, what it says it does, its
+*   arguments as a Zod shape, whether it only reads, and its call, which checks
+*   the arguments before it runs.
+*/
+const tool = (name, description, shape, run, options = {}) => {
+	const schema = z.strictObject(shape);
+	return {
+		name,
+		description,
+		shape,
+		readOnly: options.readOnly ?? true,
+		call: (args) => {
+			const parsed = schema.safeParse(args ?? {});
+			return Promise.resolve(parsed.success ? run(parsed.data) : refused(z.prettifyError(parsed.error)));
+		}
+	};
+};
+// ../server/src/write-routes.ts
+/**
+* @file The API's write routes (specs/server.md#api): answer a decision; stop,
+*   pause or continue a run or one of its nodes (ADR-041); message a live run's
+*   node; and start or resume a run in the background. Each does what its CLI
+*   command does (`ork decide --id`, `stop`, `pause`, `continue`, `chat -m`,
+*   `run --detach`, `resume --detach`), through the same functions in core:
+*   rows in the store, a wake on the run's socket, or a detached process. The
+*   server itself runs nothing.
+*/
+/** A refused pause, continue or stop: an unknown node is 404, the rest 409. */
+const commandAnswer = (runId, asked) => {
+	if (asked.ok) return accepted({ runId });
+	return fail(asked.error.includes("is not a node of") ? 404 : 409, asked.error);
+};
+/** The `ork run` / `ork resume` flags a request's options stand for. */
+const flagsOf = (options) => [
+	...Object.entries(options.inputs ?? {}).flatMap(([name, value]) => ["--input", `${name}=${value}`]),
+	...options.driver === void 0 ? [] : ["--driver", options.driver],
+	...options.inPlace === void 0 ? [] : [options.inPlace ? "--in-place" : "--no-in-place"],
+	...options.allowDirty === true ? ["--allow-dirty"] : []
+];
+const WORKFLOW_SUFFIX = ".ork.yaml";
+/**
+* A workflow file of `project`: a name in its workflows folder, or a path
+* inside the project's root or its Ork folder.
+*/
+const workflowFile = (project, workflow) => {
+	const workflows = placeFiles(project).workflows;
+	return [path.join(workflows, `${workflow}${WORKFLOW_SUFFIX}`), path.resolve(project.root, workflow)].find((file) => (inside(project.root, file) || inside(project.dir, file)) && existsSync(file) && statSync(file).isFile()) ?? null;
+};
+const answerStatus = (error) => {
+	if (error.startsWith("No decision")) return 404;
+	return error.includes("is not an option") ? 400 : 409;
+};
+const writeRoutes = (context) => {
+	const script = context.script === void 0 ? {} : { script: context.script };
+	return {
+		answer: async ({ params, body }) => {
+			const answered = await answerDecision(context.store, params.id, body.choose, context.home, "ui");
+			return answered.ok ? ok({
+				decision: params.id,
+				answer: body.choose
+			}) : fail(answerStatus(answered.error), answered.error);
+		},
+		stop: async ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const { run } = found;
+			const { store, home } = context;
+			return commandAnswer(run.id, await requestStop(store, run, home, body.node));
+		},
+		pause: async ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const { run } = found;
+			const { store, home } = context;
+			return commandAnswer(run.id, await requestPause(store, run, home, body.node));
+		},
+		continue: async ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const { run } = found;
+			const { store, home } = context;
+			return commandAnswer(run.id, await requestContinue(store, run, home, body.node));
+		},
+		message: async ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const { run } = found;
+			const { session } = nodeSession(context.store.events(run.id, 0), body.node);
+			if (!session.known) return fail(404, `${body.node} is not a node of run ${run.id}.`);
+			if (!session.chattable) return fail(400, `${body.node} is not a leader or worker; only they have sessions to talk to.`);
+			if (liveStatus(run) !== "running") return fail(409, `Run \`${run.id}\` is not running; to talk to a finished run's node, use \`ork chat ${run.id} ${body.node}\`.`);
+			await tellLiveRun(context.store, run, body.node, body.body, context.home);
+			return accepted({ runId: run.id });
+		},
+		link: async ({ body }) => {
+			const linked = await linkNodes(context.store, body.a, body.b, {
+				maxMessages: body.maxMessages,
+				home: context.home
+			});
+			return linked.ok ? ok(linked.link) : fail(409, linked.error);
+		},
+		unlink: async ({ body }) => {
+			const ended = await unlinkNodes(context.store, body.a, body.b, context.home);
+			return ended.ok ? ok({ ended: true }) : fail(404, ended.error);
+		},
+		start: async ({ body }) => {
+			const request = body;
+			const project = projectOf(context, request.project);
+			if (project === void 0) return fail(404, `No registered project \`${request.project}\`; register it with \`ork init\` or \`ork register\`.`);
+			const file = workflowFile(project, request.workflow);
+			if (file === null) return fail(404, `No workflow \`${request.workflow}\` in \`${project.id}\`'s workflows or inside its root.`);
+			const runId = newRunId(context.store);
+			const detached = await detachRun({
+				store: context.store,
+				runId,
+				args: [
+					"run",
+					file,
+					...flagsOf(request),
+					"--run-id",
+					runId
+				],
+				cwd: project.root,
+				runDir: runDirOf(project, runId),
+				...script
+			});
+			return detached.ok ? accepted({ runId }) : fail(400, detached.error || "The run did not start.");
+		},
+		resume: async ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const ready = resumable(context.store, found.run, {
+				...body.inPlace === void 0 ? {} : { inPlace: body.inPlace },
+				...body.driver === void 0 ? {} : { driver: body.driver }
+			});
+			if (!ready.ok) return fail(409, ready.error);
+			const detached = await detachResume(context.store, found.run, flagsOf(body), context.script);
+			return detached.ok ? accepted({ runId: found.run.id }) : fail(400, detached.error || "The run did not resume.");
+		}
+	};
+};
+// ../server/src/mcp-act.ts
+/**
+* @file The tools `ork mcp` gives Claude Code beyond reading (RFC-012):
+*   `check`, which checks a draft or a file as `ork validate` does, walk and
+*   all, and `start_run`, which starts a run in the background as `ork run
+*   --detach` does. Neither answers a decision; starting is the one that
+*   spends, and Claude Code asks the person before each.
+*/
+/** How many of a walk's endings `check` lists when asked for them. */
+const MOST_ENDINGS = 20;
+const project$1 = z.string().min(1).describe("A registered project's id or root");
+/** The text to check, and the file whose folder its paths resolve from. */
+const textOf = (context, key, args) => {
+	const place = projectOf(context, key);
+	if (place === void 0) return {
+		ok: false,
+		answer: refused(`No registered project \`${key}\`.`)
+	};
+	if (args.workflow === void 0 === (args.text === void 0)) return {
+		ok: false,
+		answer: refused("Give either `workflow` (a name or path) or `text`.")
+	};
+	if (args.text !== void 0) {
+		const file = path.join(placeFiles(place).workflows, "draft.ork.yaml");
+		return {
+			ok: true,
+			text: args.text,
+			file,
+			place
+		};
+	}
+	const file = workflowFile(place, args.workflow ?? "");
+	return file === null ? {
+		ok: false,
+		answer: refused(`No workflow \`${args.workflow ?? ""}\` in \`${place.id}\`'s workflows or inside its root.`)
+	} : {
+		ok: true,
+		text: readFileSync(file, "utf8"),
+		file,
+		place
+	};
+};
+const checkTool = (context) => tool("check", "Checks a workflow as `ork validate` does: a draft's `text`, or a `workflow` by name or path. It gives each problem with its line, then walks every way through without running anything. Ask for `paths` to see how a run can end.", {
+	project: project$1,
+	workflow: z.string().min(1).optional(),
+	text: z.string().min(1).optional(),
+	paths: z.boolean().optional()
+}, async (args) => {
+	const found = textOf(context, args.project, args);
+	if (!found.ok) return found.answer;
+	const { diagnostics, walk } = await walkChecks(checkWorkflowText(found.text, {
+		place: found.place,
+		workflowDir: workflowDirOf(found.place, found.file),
+		registered: context.store.projects(),
+		...context.home === void 0 ? {} : { home: context.home }
+	}));
+	const count = (severity) => diagnostics.filter((each) => each.severity === severity).length;
+	return answer({
+		errors: count("error"),
+		warnings: count("warning"),
+		diagnostics: diagnostics.map(({ severity, code, message, line, column }) => line === void 0 ? {
+			severity,
+			code,
+			message
+		} : {
+			severity,
+			code,
+			message,
+			line,
+			column
+		}),
+		walk: walk === void 0 ? null : walkSummary(walk),
+		...args.paths === true && walk !== void 0 ? { endings: walk.endings.slice(0, MOST_ENDINGS) } : {}
+	});
+});
+const startTool = (context) => {
+	const { start } = writeRoutes(context);
+	return tool("start_run", "Starts a workflow in the background, as `ork run --detach` does, and gives its run id. It spends money, and its questions wait on a person, who answers in `ork ui` or with `ork decide`.", {
+		project: project$1,
+		workflow: z.string().min(1).describe("A workflow's name, or a path"),
+		inputs: z.record(z.string(), z.string()).optional()
+	}, (args) => fromReply(start({
+		params: {},
+		query: void 0,
+		body: args
+	}), (started) => ({
+		...started,
+		next: "Follow it with `run` and `run_events`. A decision it opens waits on a person."
+	})), { readOnly: false });
+};
+/** `check`, and `start_run` where starting is allowed. */
+const actingTools = (context, options) => [checkTool(context), ...options.start ? [startTool(context)] : []];
+// ../server/src/builder-files.ts
+/**
+* @file A workflow's file for the builder (RFC-008): reading it only where it
+*   stays inside the project, and writing it, the one place the server writes
+*   into a project, whole or not at all and never through a link.
+*/
+/** Most file systems stop at 255 bytes, and the suffix takes some of those. */
+const LONGEST_NAME = 200;
+/** A name that stays one file in the workflows folder. */
+const safeName = (name) => name.length > 0 && Buffer.byteLength(name) <= LONGEST_NAME && path.basename(name) === name && !name.startsWith(".") && !name.includes("\\") && !name.includes("\0");
+/** Call only once `unreadableReason` has passed the file. */
+const readText = (file) => existsSync(file) ? readFileSync(file, "utf8") : void 0;
+const hashOf = (text) => createHash("sha256").update(text).digest("hex");
+/** A file by its contents, or `null` when there's none. */
+const hashOfFile = (file) => {
+	const text = readText(file);
+	return text === void 0 ? null : hashOf(text);
+};
+/** The folder a project's own files must stay in, links resolved. */
+const homeOf = (project) => realpathSync(inside(project.root, project.dir) ? project.root : project.dir);
+/** Whether something is at `at`, even a link that leads nowhere. */
+const isThere = (at) => lstatSync(at, { throwIfNoEntry: false }) !== void 0;
+/** The nearest existing folder on the way to `file`. */
+const nearestFolder = (file) => {
+	let folder = path.dirname(file);
+	while (!isThere(folder) && path.dirname(folder) !== folder) folder = path.dirname(folder);
+	return folder;
+};
+const folderOutside = (project, file) => {
+	const folder = nearestFolder(file);
+	return !existsSync(folder) || !existsSync(project.root) || !existsSync(project.dir) || !inside(homeOf(project), realpathSync(folder));
+};
+const LEADS_OUT = "The workflows folder leads out of the project, so Ork won't use it.";
+/** Why this file may not be read; a link could lead out of the project. */
+const unreadableReason = (project, file) => {
+	if (folderOutside(project, file)) return LEADS_OUT;
+	if (!isThere(file)) return void 0;
+	if (!existsSync(file) || !inside(homeOf(project), realpathSync(file))) return `${path.basename(file)} is a link that leads out of the project, so Ork won't read it.`;
+	return statSync(file).isFile() ? void 0 : `${path.basename(file)} isn't a file.`;
+};
+/** Why this file may not be written: it must not be a link at all. */
+const outsideReason = (project, file) => {
+	if (folderOutside(project, file)) return LEADS_OUT;
+	const found = lstatSync(file, { throwIfNoEntry: false });
+	if (found?.isSymbolicLink() === true) return `${path.basename(file)} is a symbolic link, so Ork won't write through it.`;
+	return found === void 0 || found.isFile() ? void 0 : `${path.basename(file)} isn't a file.`;
+};
+/** Writes `text` so that a reader sees the old file or the new, never part. */
+const writeWhole = (file, text) => {
+	mkdirSync(path.dirname(file), { recursive: true });
+	const temporary = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+	writeFileSync(temporary, text, { flag: "wx" });
+	try {
+		if (existsSync(file)) chmodSync(temporary, statSync(file).mode);
+		renameSync(temporary, file);
+	} catch (failed) {
+		rmSync(temporary, { force: true });
+		throw failed;
+	}
+};
+// ../server/src/builder-graph.ts
+/**
+* @file The graph of a draft (RFC-008). A draft isn't valid until it's
+*   finished, so this reads what the text says rather than the parsed workflow:
+*   a node with no type yet still gets a card, and an edge that can't be read
+*   is left for the checks to report.
+*/
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const asArray = (value) => Array.isArray(value) ? value : [];
+const EMPTY = {
+	nodes: [],
+	edges: [],
+	channels: []
+};
+/** The nodes finished enough to say what they'd report. */
+const validNodes = (document) => Object.fromEntries(Object.entries(isRecord(document["nodes"]) ? document["nodes"] : {}).flatMap(([id, node]) => {
+	const parsed = NodeSchema.safeParse(node);
+	return parsed.success ? [[id, parsed.data]] : [];
+}));
+/** What the text says, and the graph to draw from it. */
+const draftGraph = (text) => {
+	const document = readDocument(text);
+	if (!isRecord(document)) return {
+		document: document ?? null,
+		graph: EMPTY
+	};
+	const nodes = isRecord(document["nodes"]) ? Object.entries(document["nodes"]).map(([id, node]) => ({
+		id,
+		type: isRecord(node) && typeof node["type"] === "string" ? node["type"] : "",
+		parent: isRecord(node) && typeof node["parent"] === "string" ? node["parent"] : void 0
+	})) : [];
+	const edges = asArray(document["edges"]).flatMap((input, index) => {
+		const parsed = EdgeInputSchema.safeParse(input);
+		if (!parsed.success) return [];
+		const expanded = expandEdge(parsed.data, index);
+		return expanded.ok ? expanded.edges.map(({ from, to, when, maxRounds }) => ({
+			from,
+			to,
+			when,
+			maxRounds,
+			condition: readCondition(when)
+		})) : [];
+	});
+	const channels = asArray(document["messages"]).flatMap((channel) => {
+		const [a, b] = isRecord(channel) ? asArray(channel["between"]) : [];
+		return typeof a === "string" && typeof b === "string" ? [[a, b]] : [];
+	});
+	const untils = isRecord(document["nodes"]) ? Object.entries(document["nodes"]).flatMap(([id, node]) => {
+		const watch = isRecord(node) ? node["watch"] : void 0;
+		const until = isRecord(watch) ? watch["until"] : void 0;
+		return typeof until === "string" ? [[id, readCondition(until)]] : [];
+	}) : [];
+	return {
+		document,
+		graph: {
+			nodes,
+			edges,
+			channels,
+			says: nodeSays(validNodes(document), edges),
+			untils: Object.fromEntries(untils)
+		}
+	};
+};
+// ../server/src/builder-view.ts
+/**
+* @file What the builder shows for a workflow's text (RFC-008): what it says,
+*   its graph, what the checks say, and what walking it found (RFC-009), which
+*   never stops a save.
+*/
+const SUFFIX$1 = ".ork.yaml";
+const fileOf = (project, name) => path.join(placeFiles(project).workflows, `${name}${SUFFIX$1}`);
+/** The workflow as it stands: its draft, or else its file. */
+const viewOf$1 = async (context, project, name, text) => {
+	const file = fileOf(project, name);
+	const { diagnostics, workflow, walk } = await walkChecks(checkWorkflowText(text, {
+		place: project,
+		workflowDir: workflowDirOf(project, file),
+		registered: context.store.projects(),
+		home: context.home
+	}), { maxMs: 200 });
+	const draft = context.store.draft(project.id, name);
+	const onDisk = hashOfFile(file);
+	const graph = draftGraph(text);
+	return {
+		name,
+		file,
+		text,
+		document: graph.document,
+		graph: workflow === null ? graph.graph : {
+			...graph.graph,
+			says: nodeSays(workflow.nodes, graph.graph.edges)
+		},
+		diagnostics,
+		walk: walk === void 0 ? null : walkSummary(walk),
+		draft: draft !== void 0,
+		baseHash: draft === void 0 ? onDisk : draft.baseHash,
+		changedOnDisk: draft !== void 0 && onDisk !== draft.baseHash
+	};
+};
+// ../server/src/builder.ts
+/**
+* @file The workflow builder's files and drafts (RFC-008): what a workflow is
+*   while it's edited, applying edits to its draft, and saving it. This is the
+*   only place the server writes a project's files, and it writes only a valid
+*   workflow, inside the project's workflows folder.
+*/
+const notFound = (project, name) => ({
+	refused: 404,
+	error: `No workflow \`${name}\` in \`${project.id}\`'s workflows.`
+});
+const badName = (name) => ({
+	refused: 400,
+	error: `\`${name}\` can't be a workflow's file name.`
+});
+/** Why this workflow can't be touched at all, by its name or where it leads. */
+const problemWith = (project, name) => {
+	if (!safeName(name)) return badName(name);
+	const reason = unreadableReason(project, fileOf(project, name));
+	return reason === void 0 ? void 0 : {
+		refused: 409,
+		error: reason
+	};
+};
+/** What the builder shows for a workflow. */
+const builderView = async (context, project, name) => {
+	const problem = problemWith(project, name);
+	if (problem !== void 0) return problem;
+	const text = context.store.draft(project.id, name)?.text ?? readText(fileOf(project, name));
+	if (text === void 0) return notFound(project, name);
+	return await viewOf$1(context, project, name, text);
+};
+const NAME = /^[a-z0-9][a-z0-9._-]*$/u;
+/** Starts a draft of a new workflow. */
+const createDraft = async (context, project, name) => {
+	if (!NAME.test(name) || !safeName(name)) return {
+		refused: 400,
+		error: "A workflow's name is a lowercase slug, such as nightly-review."
+	};
+	const problem = problemWith(project, name);
+	if (problem !== void 0) return problem;
+	if (existsSync(fileOf(project, name)) || context.store.draft(project.id, name) !== void 0) return {
+		refused: 409,
+		error: `There is already a workflow \`${name}\`.`
+	};
+	const text = newWorkflowText(name);
+	context.store.putDraft({
+		project: project.id,
+		workflow: name,
+		text,
+		baseHash: null,
+		at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return await viewOf$1(context, project, name, text);
+};
+/**
+* Stores new text as the draft, or drops it if it's back to the file's. A draft
+* remembers the file it began from; `baseHash` says so when there's no draft
+* yet to remember it, and otherwise it's the file as it is now.
+*/
+const keep = (context, project, name, text, baseHash) => {
+	const file = fileOf(project, name);
+	const draft = context.store.draft(project.id, name);
+	if (text === readText(file)) {
+		context.store.dropDraft(project.id, name);
+		return;
+	}
+	context.store.putDraft({
+		project: project.id,
+		workflow: name,
+		text,
+		baseHash: draft === void 0 ? baseHash === void 0 ? hashOfFile(file) : baseHash : draft.baseHash,
+		at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+};
+/** Applies edits to the draft, starting one from the file if there's none. */
+const editDraft = async (context, project, name, edits) => {
+	const problem = problemWith(project, name);
+	if (problem !== void 0) return problem;
+	const checked = WorkflowEditSchema.array().safeParse(edits);
+	if (!checked.success) return {
+		refused: 400,
+		error: checked.error.issues[0]?.message ?? "That isn't an edit."
+	};
+	const draft = context.store.draft(project.id, name);
+	const file = fileOf(project, name);
+	const text = draft?.text ?? readText(file);
+	if (text === void 0) return notFound(project, name);
+	const result = applyEdits(text, checked.data);
+	if (!result.ok) return {
+		refused: 409,
+		error: result.message
+	};
+	const previous = {
+		text,
+		baseHash: draft === void 0 ? hashOfFile(file) : draft.baseHash
+	};
+	keep(context, project, name, result.text);
+	return {
+		...await viewOf$1(context, project, name, result.text),
+		previous
+	};
+};
+/** Puts a draft back to earlier text: the builder's undo. */
+const restoreDraft = async (context, project, name, text, baseHash) => {
+	const problem = problemWith(project, name);
+	if (problem !== void 0) return problem;
+	if (!(context.store.draft(project.id, name) !== void 0 || existsSync(fileOf(project, name)))) return notFound(project, name);
+	keep(context, project, name, text, baseHash);
+	return await viewOf$1(context, project, name, text);
+};
+/** Throws away a draft; what's left is the file, if there is one. */
+const discardDraft = async (context, project, name) => {
+	if (!safeName(name)) return badName(name);
+	context.store.dropDraft(project.id, name);
+	const problem = problemWith(project, name);
+	if (problem !== void 0) return problem;
+	const text = readText(fileOf(project, name));
+	if (text === void 0) return { gone: true };
+	return await viewOf$1(context, project, name, text);
+};
+/**
+* Saves a draft to the workflows folder. Errors block it, as a running
+* workflow's call could read the file, and so does a file that changed since
+* the draft began, unless the user chooses to replace it.
+*/
+const saveDraft = (context, project, name, force) => {
+	if (!safeName(name)) return badName(name);
+	const file = fileOf(project, name);
+	const outside = outsideReason(project, file);
+	if (outside !== void 0) return {
+		refused: 409,
+		error: outside
+	};
+	const draft = context.store.draft(project.id, name);
+	if (draft === void 0) return existsSync(file) ? {
+		saved: true,
+		file
+	} : notFound(project, name);
+	const { diagnostics } = checkWorkflowText(draft.text, {
+		place: project,
+		workflowDir: workflowDirOf(project, file),
+		registered: context.store.projects(),
+		home: context.home
+	});
+	const errors = diagnostics.filter((d) => d.severity === "error").length;
+	if (errors > 0) return {
+		saved: false,
+		why: "errors",
+		message: `Fix ${errors === 1 ? "the error" : `the ${String(errors)} errors`} first; nothing was saved.`
+	};
+	if (!force && hashOfFile(file) !== draft.baseHash) return {
+		saved: false,
+		why: "changed",
+		message: `${path.basename(file)} changed since this draft began; nothing was saved.`
+	};
+	writeWhole(file, draft.text);
+	context.store.dropDraft(project.id, name);
+	return {
+		saved: true,
+		file
+	};
+};
+// ../server/src/builder-routes.ts
+/**
+* @file The workflow builder's routes (RFC-008, specs/server.md#api). Each
+*   finds the project, then does its work in `builder.ts`, and a refusal has
+*   the words the user will see.
+*/
+const isRefused = (answer) => "refused" in answer;
+const replyOf = (answer) => isRefused(answer) ? fail(answer.refused, answer.error) : ok(answer);
+const builderRoutes = (context) => {
+	/** The answer for a registered project; a 404 for any other. */
+	const inProject = (id, work) => {
+		const project = projectOf(context, id);
+		return project === void 0 ? fail(404, `No registered project \`${id}\`.`) : replyOf(work(project));
+	};
+	/** The same, for work the server walks a workflow for. */
+	const walkedInProject = async (id, work) => {
+		const project = projectOf(context, id);
+		return project === void 0 ? fail(404, `No registered project \`${id}\`.`) : replyOf(await work(project));
+	};
+	return {
+		builderSchema: () => ok(JSON.parse(renderJsonSchema())),
+		builderCatalog: ({ params }) => inProject(params.id, (project) => {
+			const home = context.home ?? homedir();
+			return {
+				agents: loadAgents({
+					projectRoot: project.root,
+					orkDir: project.dir,
+					home
+				}).agents.map(({ name, source, agent }) => ({
+					name,
+					description: agent.description ?? "",
+					source
+				})),
+				skills: [...skillsIn(path.join(home, ".ork", "skills"), "user"), ...skillsIn(path.join(project.root, ".claude", "skills"), "project")].map(({ name, layer }) => ({
+					name,
+					layer
+				}))
+			};
+		}),
+		builderDrafts: ({ params }) => inProject(params.id, (project) => {
+			return context.store.drafts(project.id).map(({ workflow }) => workflow);
+		}),
+		builderView: ({ params }) => walkedInProject(params.id, (project) => builderView(context, project, params.name)),
+		builderCreate: ({ params, body }) => walkedInProject(params.id, (project) => createDraft(context, project, body.name)),
+		builderEdit: ({ params, body }) => walkedInProject(params.id, (project) => editDraft(context, project, params.name, body.edits)),
+		builderRestore: ({ params, body }) => walkedInProject(params.id, (project) => restoreDraft(context, project, params.name, body.text, body.baseHash)),
+		builderDiscard: ({ params }) => walkedInProject(params.id, (project) => discardDraft(context, project, params.name)),
+		builderSave: ({ params, body }) => inProject(params.id, (project) => saveDraft(context, project, params.name, body.force === true))
+	};
+};
+// ../server/src/workflows.ts
+/**
+* @file A project's workflows, for the UI's Run workflow dialog: each
+*   `*.ork.yaml` in its workflows folder, with its name, description and
+*   declared inputs; one that does not parse is listed with why, since starting
+*   it is how the user sees the whole error.
+*/
+const SUFFIX = ".ork.yaml";
+const viewOf = (file) => {
+	const name = path.basename(file).slice(0, -9);
+	let text;
+	try {
+		text = readFileSync(file, "utf8");
+	} catch (error) {
+		return {
+			name,
+			file,
+			inputs: {},
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	const parsed = parseWorkflow(text);
+	if (!parsed.ok) {
+		const [first] = parsed.diagnostics;
+		return {
+			name,
+			file,
+			inputs: {},
+			error: first?.message ?? "It is not a valid workflow."
+		};
+	}
+	const { workflow } = parsed;
+	return {
+		name,
+		file,
+		title: workflow.name,
+		...workflow.description === void 0 ? {} : { description: workflow.description },
+		inputs: workflow.inputs ?? {}
+	};
+};
+/** The workflows in `project`'s workflows folder, by name. */
+const projectWorkflows = (project) => {
+	const folder = placeFiles(project).workflows;
+	let names;
+	try {
+		names = readdirSync(folder);
+	} catch {
+		return [];
+	}
+	return names.filter((name) => name.endsWith(SUFFIX)).toSorted().map((name) => viewOf(path.join(folder, name)));
+};
+// ../server/src/read-routes.ts
+/**
+* @file The API's read routes (specs/server.md#api): health, projects and a
+*   project's workflows, runs, a run, its tree and its events, the open
+*   decisions, and usage. Each reads the store as the matching CLI command does
+*   (`ork projects`, `ps`, `tree`, `logs`, `decide --list`, `usage`).
+*/
+/** A project filter's root: a registered project's, or the value as a root. */
+/** A registered project's place; caps are only known for one. */
+const placeOf = (context, key) => {
+	const known = key === void 0 ? void 0 : projectOf(context, key);
+	return known === void 0 ? void 0 : placeFor(known.root, context.store.projects());
+};
+const projectRoot = (context, key) => projectOf(context, key)?.root ?? key;
+const readRoutes = (context) => ({
+	health: () => ok({
+		version: context.version,
+		pid: context.pid,
+		startedAt: context.startedAt
+	}),
+	projects: () => ok(context.store.projects()),
+	triggers: () => ok(triggersReport(context.store, context.store.projects(), context.home)),
+	links: ({ query }) => ok(context.store.links(query.run === void 0 ? {} : { run: query.run })),
+	usage: ({ query }) => ok({
+		...usageReport(context.store.usage({
+			...query.project === void 0 ? {} : { project: projectRoot(context, query.project) },
+			...query.workflow === void 0 ? {} : { workflow: query.workflow },
+			...query.since === void 0 ? {} : { since: query.since },
+			...query.until === void 0 ? {} : { until: query.until }
+		})),
+		limits: limitsReport(context.store, capsHere(context.home, placeOf(context, query.project)), /* @__PURE__ */ new Date())
+	}),
+	workflows: ({ params }) => {
+		const project = projectOf(context, params.id);
+		return project === void 0 ? fail(404, `No registered project \`${params.id}\`.`) : ok(projectWorkflows(project));
+	},
+	runs: ({ query }) => ok(context.store.runs({
+		limit: query.limit ?? 20,
+		...query.project === void 0 ? {} : { project: projectRoot(context, query.project) }
+	}).map((run) => viewOf$2(context, run))),
+	run: ({ params }) => {
+		const found = runOf(context, params.id);
+		return found.ok ? ok(viewOf$2(context, found.run)) : found.refusal;
+	},
+	tree: ({ params }) => {
+		const found = runOf(context, params.id);
+		if (!found.ok) return found.refusal;
+		return ok(activeTree(context.store.events(found.run.id)));
+	},
+	graph: ({ params }) => {
+		const found = runOf(context, params.id);
+		if (!found.ok) return found.refusal;
+		return ok(runGraph(context.store.events(found.run.id).map((s) => s.event), found.run.file));
+	},
+	events: ({ params, query }) => {
+		const found = runOf(context, params.id);
+		if (!found.ok) return found.refusal;
+		const events = context.store.events(found.run.id, query.after ?? 0).filter((s) => query.node === void 0 || nodeOf(s.event) === query.node);
+		const newest = query.last === void 0 ? events : events.slice(-query.last);
+		return ok(query.limit === void 0 ? newest : newest.slice(0, query.limit));
+	},
+	decisions: ({ query }) => {
+		if (query.run === void 0) return ok(pendingDecisions(context.store, query.project === void 0 ? {} : { project: projectRoot(context, query.project) }));
+		const found = runOf(context, query.run);
+		if (!found.ok) return found.refusal;
+		return ok(pendingDecisions(context.store, { runId: found.run.id }));
+	},
+	decision: ({ params }) => {
+		const found = context.store.decision(params.id);
+		return found === void 0 ? fail(404, `No decision \`${params.id}\`.`) : ok(found);
+	}
+});
+// ../server/src/mcp-tools.ts
+/**
+* @file The tools `ork mcp` serves Claude Code (RFC-012): what a project has,
+*   the workflow format, runs, their events, what they spent, and what waits on
+*   a person. Each answers from the same handler as `ork ui`'s API, and they
+*   are built from its read routes and the builder's catalog alone, so none can
+*   answer a decision, start, stop, pause or message a run.
+*/
+const NO_QUERY = {
+	params: {},
+	query: void 0,
+	body: void 0
+};
+/** How many events `run_events` gives when it's asked for no range. */
+const RECENT_EVENTS = 30;
+/** Said with the open decisions: this server can't answer them. */
+const ANSWERED_BY_A_PERSON = "Only a person answers these: in `ork ui`, or with `ork decide` in their own terminal. Tell them what waits, and where.";
+const project = z.string().min(1).describe("A registered project's id or root");
+const run = z.string().min(1).describe("A run's id, or a unique start of it");
+const mcpTools = (context) => {
+	const read = readRoutes(context);
+	const { builderCatalog } = builderRoutes(context);
+	return [
+		tool("projects", "The projects registered with Ork on this machine.", {}, () => fromReply(read.projects(NO_QUERY))),
+		tool("workflows", "A project's workflows: each one's name to start it by, its description and inputs, or why it doesn't parse.", { project }, (args) => fromReply(read.workflows({
+			...NO_QUERY,
+			params: { id: args.project }
+		}))),
+		tool("workflow_format", "The workflow file format's JSON Schema. With no node type: the workflow's own fields and the node types there are. With one: that node type's fields.", { nodeType: z.string().min(1).optional() }, (args) => formatPart(args.nodeType)),
+		tool("agents", "The agents and skills a project's nodes can use, and where each comes from.", { project }, (args) => fromReply(builderCatalog({
+			...NO_QUERY,
+			params: { id: args.project }
+		}))),
+		tool("runs", "Runs, newest first, with their live status and cost. 10 unless a limit is given.", RunsQuerySchema.shape, (args) => fromReply(read.runs({
+			...NO_QUERY,
+			query: {
+				limit: 10,
+				...args
+			}
+		}))),
+		tool("run", "One run: its status, what it waits on, its cost, and each node's state.", { run }, async (args) => {
+			const view = await read.run({
+				...NO_QUERY,
+				params: { id: args.run }
+			});
+			if ("error" in view) return refused(view.error);
+			const tree = read.tree({
+				...NO_QUERY,
+				params: { id: view.body.id }
+			});
+			return fromReply(tree, (nodes) => ({
+				run: view.body,
+				nodes
+			}));
+		}),
+		tool("run_events", `A run's events, oldest first, long values cut. With no range, the newest ${String(RECENT_EVENTS)}.`, {
+			run,
+			...EventsQuerySchema.shape
+		}, ({ run: id, ...query }) => {
+			const range = query.after === void 0 && query.limit === void 0 && query.last === void 0 ? { last: RECENT_EVENTS } : {};
+			return fromReply(read.events({
+				...NO_QUERY,
+				params: { id },
+				query: {
+					...range,
+					...query
+				}
+			}));
+		}),
+		tool("usage", "What runs spent, by workflow and model, and how close the limits are. `since` and `until` are ISO times.", UsageQuerySchema.shape, (args) => fromReply(read.usage({
+			...NO_QUERY,
+			query: args
+		}))),
+		tool("decisions", "The decisions open in live runs, waiting on a person. This server can't answer them.", DecisionsQuerySchema.shape, (args) => fromReply(read.decisions({
+			...NO_QUERY,
+			query: args
+		}), (open) => ({
+			open,
+			answer: ANSWERED_BY_A_PERSON
+		})))
+	];
+};
+// ../server/src/mcp.ts
+/**
+* @file What `ork mcp` opens (RFC-012): the store under a home, and the tools
+*   on it, as one more client of the store beside the CLI and `ork ui`.
+*   Starting a run is offered only where the caller allows it: not inside a
+*   run, whose sessions mustn't start more.
+*/
+const openMcp = (options) => {
+	const store = openStore(storePath(options.home));
+	const context = {
+		store,
+		version: options.version,
+		pid: process.pid,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.script === void 0 ? {} : { script: options.script }
+	};
+	return {
+		tools: [...mcpTools(context), ...actingTools(context, { start: options.start })],
+		fileOf: (key, workflow) => {
+			const project = projectOf(context, key);
+			if (project === void 0) return { error: `No registered project \`${key}\`.` };
+			const file = workflowFile(project, workflow);
+			return file === null ? { error: `No workflow \`${workflow}\` in \`${project.id}\`'s workflows or inside its root.` } : {
+				project,
+				file
+			};
+		},
+		close: () => {
+			store.close();
+		}
+	};
+};
+// ../server/src/assets.ts
+/**
+* @file The built UI's files (`packages/ui/dist`, shipped as the CLI's
+*   `dist/ui`): `/` is its `index.html`, and `/assets/…` are its hashed files,
+*   cached for good. Only a file inside the folder, with a known type, is
+*   served; anything else is none.
+*/
+/** The types the UI's build writes; anything else is not served. */
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".woff": "font/woff",
+	".txt": "text/plain; charset=utf-8",
+	".webmanifest": "application/manifest+json"
+};
+/** Whether `dir` holds a built UI. */
+const hasUi = (dir) => {
+	try {
+		return statSync(path.join(dir, "index.html")).isFile();
+	} catch {
+		return false;
+	}
+};
+/** The file `pathname` names in the built UI `dir`, or null. */
+const readAsset = (dir, pathname) => {
+	const relative = pathname === "/" ? "index.html" : pathname.slice(1);
+	let decoded;
+	try {
+		decoded = decodeURIComponent(relative);
+	} catch {
+		return null;
+	}
+	const root = path.resolve(dir);
+	const file = path.resolve(root, decoded);
+	const type = TYPES[path.extname(file)];
+	if (type === void 0 || !file.startsWith(`${root}${path.sep}`)) return null;
+	try {
+		if (!statSync(file).isFile()) return null;
+		return {
+			body: readFileSync(file),
+			type,
+			immutable: decoded.startsWith("assets/")
+		};
+	} catch {
+		return null;
+	}
+};
+// ../server/src/api-routes.ts
+/** @file Every JSON route's handler, in one place. */
+const apiRoutes = (context) => ({
+	...readRoutes(context),
+	...writeRoutes(context),
+	...builderRoutes(context)
+});
+const PLACEHOLDER_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Ork</title>
+<style>
+  :root { color-scheme: light dark; --fg: #1d1f23; --muted: #6b7079; --bg: #fbfbfa; --line: #e3e3e0; }
+  @media (prefers-color-scheme: dark) { :root { --fg: #e6e6e3; --muted: #9a9ea6; --bg: #16171a; --line: #2a2c31; } }
+  body { margin: 0; background: var(--bg); color: var(--fg); font: 15px/1.5 ui-sans-serif, system-ui, sans-serif; }
+  main { max-width: 760px; margin: 0 auto; padding: 40px 16px; }
+  h1 { font-size: 22px; margin: 0 0 4px; }
+  h2 { font-size: 15px; margin: 28px 0 8px; }
+  p, .muted { color: var(--muted); }
+  ul { list-style: none; padding: 0; margin: 0; border-top: 1px solid var(--line); }
+  li { padding: 8px 0; border-bottom: 1px solid var(--line); font-family: ui-monospace, monospace; font-size: 13px; overflow-wrap: anywhere; }
+  code { font-family: ui-monospace, monospace; }
+</style>
+</head>
+<body>
+<main>
+  <h1>Ork</h1>
+  <p id="status">The server is running. The UI's panels come in the next releases; until then, this page lists what the API sees.</p>
+  <h2>Open decisions</h2>
+  <ul id="decisions"><li class="muted">Loading…</li></ul>
+  <h2>Runs</h2>
+  <ul id="runs"><li class="muted">Loading…</li></ul>
+  <p>Answer with <code>ork decide</code>; follow a run with <code>ork logs &lt;run&gt; -f</code>.</p>
+</main>
+<script src="/placeholder.js"><\/script>
+</body>
+</html>
+`;
+const PLACEHOLDER_JS = `"use strict";
+const fill = (id, items, line, empty) => {
+  const list = document.getElementById(id);
+  list.replaceChildren();
+  if (items.length === 0) items = [null];
+  for (const item of items) {
+    const li = document.createElement("li");
+    li.textContent = item === null ? empty : line(item);
+    if (item === null) li.className = "muted";
+    list.append(li);
+  }
+};
+fetch("/api/health").then(r => r.json()).then(h => {
+  document.title = "Ork " + h.version;
+});
+const events = new EventSource("/api/stream");
+events.addEventListener("runs", e => fill("runs", JSON.parse(e.data),
+  r => r.id + "  " + r.live.padEnd(9) + "  " + r.workflow + "  " + r.startedAt.slice(0, 16).replace("T", " "),
+  "No runs yet."));
+events.addEventListener("decisions", e => fill("decisions", JSON.parse(e.data),
+  d => d.id + "  " + d.node + "  " + d.question + "  [" + d.options.map(o => o.id).join(", ") + "]",
+  "None."));
+events.onerror = () => {
+  document.getElementById("status").textContent = "Lost the server; it may have stopped (start it with ork ui).";
+};
+`;
+// ../server/src/page.ts
+/**
+* No inline script and no `eval`. Inline `style` attributes are allowed
+* (`style-src-attr`): the UI's panels, popups and graph position themselves
+* with them; style sheets still come only from the server.
+*/
+const PAGE_POLICY = [
+	"default-src 'self'",
+	"script-src 'self'",
+	"style-src 'self'",
+	"style-src-attr 'unsafe-inline'",
+	"font-src 'self'",
+	"img-src 'self' data:",
+	"connect-src 'self'",
+	"frame-ancestors 'none'",
+	"base-uri 'none'",
+	"form-action 'self'",
+	"object-src 'none'"
+].join("; ");
+const send = (res, status, type, body, cache) => {
+	res.writeHead(status, {
+		...BASE_HEADERS,
+		...cache === void 0 ? {} : { "cache-control": cache },
+		"content-security-policy": PAGE_POLICY,
+		"content-type": type
+	}).end(body);
+};
+/** A refusal for a person at the browser, not for a script. */
+const sendNotice = (res, status, text) => {
+	send(res, status, "text/plain; charset=utf-8", `${text}\n`);
+};
+const sendPlaceholder = (res, pathname) => {
+	if (pathname === "/placeholder.js") send(res, 200, "text/javascript; charset=utf-8", PLACEHOLDER_JS);
+	else if (pathname === "/") send(res, 200, "text/html; charset=utf-8", PLACEHOLDER_HTML);
+	else sendNotice(res, 404, `Nothing at ${pathname}.`);
+};
+/**
+* Answers a page request from the built UI in `uiDir` (or the placeholder
+* without one): the file, or 404 / 405.
+*/
+const sendPage = (res, method, pathname, uiDir) => {
+	if (method !== "GET" && method !== "HEAD") {
+		sendNotice(res, 405, `${method} is not allowed here.`);
+		return;
+	}
+	if (uiDir === void 0) {
+		sendPlaceholder(res, pathname);
+		return;
+	}
+	const asset = readAsset(uiDir, pathname);
+	if (asset === null) sendNotice(res, 404, `Nothing at ${pathname}.`);
+	else send(res, 200, asset.type, asset.body, asset.immutable ? "public, max-age=31536000, immutable" : void 0);
+};
+// ../server/src/streams.ts
+/** How often the overview stream compares the store. */
+const OVERVIEW_INTERVAL_MS = 1e3;
+/** How many runs the overview stream sends. */
+const OVERVIEW_RUNS = 50;
+/** The seq to start after: `Last-Event-ID`, else `?after=`, else 0. */
+const startAfter = (req, url) => {
+	const header = req.headers["last-event-id"];
+	const raw = (Array.isArray(header) ? header[0] : header) ?? url.searchParams.get("after") ?? "0";
+	const after = Number(raw);
+	return Number.isInteger(after) && after >= 0 ? after : null;
+};
+const runStream = async (context, req, res, url, id, shutdown) => {
+	const found = runOf(context, id);
+	if (!found.ok) {
+		sendError(res, found.refusal.status, found.refusal.error);
+		return;
+	}
+	const after = startAfter(req, url);
+	if (after === null) {
+		sendError(res, 400, "Last-Event-ID or after must be a sequence number.");
+		return;
+	}
+	const stream = openEventStream(res);
+	const end = await followEvents(context.store, found.run.id, (stored) => {
+		stream.send("run-event", stored, stored.seq);
+	}, {
+		follow: true,
+		after,
+		...context.home === void 0 ? {} : { home: context.home },
+		signal: AbortSignal.any([stream.signal, shutdown])
+	});
+	if (end !== "aborted" && end !== "stored") stream.send("end", { reason: end });
+	stream.close();
+};
+const overviewStream = (context, res, url, shutdown) => {
+	const key = url.searchParams.get("project");
+	const root = key === null ? void 0 : projectOf(context, key)?.root ?? key;
+	const stream = openEventStream(res);
+	const last = {
+		runs: "",
+		decisions: ""
+	};
+	const tick = () => {
+		const filter = root === void 0 ? {} : { project: root };
+		const runs = context.store.runs({
+			...filter,
+			limit: OVERVIEW_RUNS
+		}).map((run) => viewOf$2(context, run));
+		const decisions = pendingDecisions(context.store, filter);
+		for (const [name, value] of [["runs", runs], ["decisions", decisions]]) {
+			const text = JSON.stringify(value);
+			if (text === last[name]) continue;
+			last[name] = text;
+			stream.send(name, value);
+		}
+	};
+	tick();
+	const timer = setInterval(tick, OVERVIEW_INTERVAL_MS);
+	const stop = () => {
+		clearInterval(timer);
+		stream.close();
+	};
+	stream.signal.addEventListener("abort", stop);
+	shutdown.addEventListener("abort", stop, { signal: stream.signal });
+};
+// ../server/src/dispatch.ts
+const RUN_STREAM = compilePath(STREAMS.run);
+const createDispatch = (context, access) => {
+	const handlers = apiRoutes(context);
+	return async (req, res) => {
+		const method = req.method ?? "GET";
+		const url = new URL(req.url ?? "/", "http://127.0.0.1");
+		const api = url.pathname.startsWith("/api/");
+		const verdict = guard({
+			method,
+			url: req.url ?? "/",
+			headers: req.headers
+		}, {
+			port: access.port(),
+			token: access.token
+		});
+		if (verdict.kind === "refuse") {
+			if (api) sendError(res, verdict.status, verdict.error);
+			else sendNotice(res, verdict.status, verdict.error);
+			return;
+		}
+		if (verdict.kind === "exchange") {
+			res.writeHead(302, {
+				...BASE_HEADERS,
+				location: verdict.location,
+				"set-cookie": verdict.cookie
+			}).end();
+			return;
+		}
+		const streamed = RUN_STREAM.pattern.exec(url.pathname);
+		if (method === "GET" && streamed !== null) {
+			const id = decodeURIComponent(streamed[1] ?? "");
+			await runStream(context, req, res, url, id, access.shutdown);
+			return;
+		}
+		if (method === "GET" && url.pathname === STREAMS.overview) {
+			overviewStream(context, res, url, access.shutdown);
+			return;
+		}
+		if (await route(handlers, req, res, url)) return;
+		if (api) sendError(res, 404, `No API route ${url.pathname}.`);
+		else sendPage(res, method, url.pathname, context.uiDir);
+	};
+};
+// ../server/src/ui-file.ts
+/**
+* @file `~/.ork/ui.json`: the running server's port, pid, token and start time
+*   (ADR-039). It is written with mode 0600 when the server starts, so a second
+*   `ork ui` finds and opens the running one, and removed when it stops. A
+*   record whose process is gone counts as none.
+*/
+const UiRecordSchema = z.object({
+	port: z.int().min(1).max(65535),
+	pid: z.int().positive(),
+	token: z.string().min(1),
+	startedAt: z.string()
+});
+/** Where the record lives; `home` is `~` (tests pass a folder). */
+const uiFilePath = (home = homedir()) => path.join(home, ".ork", "ui.json");
+/** The record, or `null` when there is none or it cannot be read. */
+const readUiFile = (file) => {
+	try {
+		const parsed = UiRecordSchema.safeParse(JSON.parse(readFileSync(file, "utf8")));
+		return parsed.success ? parsed.data : null;
+	} catch {
+		return null;
+	}
+};
+/** Writes the record readable by the user only, replacing any other. */
+const writeUiFile = (file, record) => {
+	mkdirSync(path.dirname(file), { recursive: true });
+	const temporary = `${file}.${String(process.pid)}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 384 });
+	chmodSync(temporary, 384);
+	renameSync(temporary, file);
+};
+/** Removes the record, if it is still the one of the server `pid`. */
+const removeUiFile = (file, pid) => {
+	if (readUiFile(file)?.pid === pid) rmSync(file, { force: true });
+};
+/** The record of a server that is still running, or `null`. */
+const runningServer = (file) => {
+	const record = readUiFile(file);
+	return record !== null && processAlive(record.pid) ? record : null;
+};
+// ../server/src/server.ts
+/**
+* @file Starts the local server (ADR-039, specs/server.md): `node:http` on
+*   loopback only, every request through the guards, then the event streams,
+*   the JSON routes, and the page. It opens the store as one more client and
+*   runs nothing itself; it records itself in `~/.ork/ui.json` while it runs.
+*/
+/** The port `ork ui` serves on unless told otherwise. */
+const DEFAULT_PORT = 4417;
+const listen = (server, port) => new Promise((resolve, reject) => {
+	server.once("error", (error) => {
+		reject(error.code === "EADDRINUSE" ? /* @__PURE__ */ new Error(`Port ${String(port)} is in use; start Ork's UI on another with \`--port <n>\`.`) : error);
+	});
+	server.listen(port, "127.0.0.1", () => {
+		resolve(server.address().port);
+	});
+});
+const startServer = async (options) => {
+	const store = openStore(storePath(options.home));
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const uiDir = options.ui?.find((dir) => hasUi(dir));
+	const context = {
+		store,
+		version: options.version,
+		pid: process.pid,
+		startedAt,
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.script === void 0 ? {} : { script: options.script },
+		...uiDir === void 0 ? {} : { uiDir }
+	};
+	const token = newToken();
+	const shutdown = new AbortController();
+	const log = options.log ?? ((line) => {
+		process.stderr.write(`${line}\n`);
+	});
+	let port = options.port ?? 4417;
+	const handle = createDispatch(context, {
+		port: () => port,
+		token,
+		shutdown: shutdown.signal
+	});
+	const server = createServer((req, res) => {
+		handle(req, res).catch((error) => {
+			log(`ork ui: ${req.method ?? ""} ${req.url?.split("?")[0] ?? ""} failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (res.headersSent) res.destroy();
+			else sendError(res, 500, "The server failed; see its terminal.");
+		});
+	});
+	try {
+		port = await listen(server, port);
+	} catch (error) {
+		store.close();
+		throw error;
+	}
+	const file = uiFilePath(options.home);
+	if (options.record !== false) writeUiFile(file, {
+		port,
+		pid: process.pid,
+		token,
+		startedAt
+	});
+	let closed;
+	return {
+		port,
+		url: `http://127.0.0.1:${String(port)}`,
+		token,
+		close: () => {
+			closed ??= new Promise((resolve) => {
+				shutdown.abort();
+				server.close(() => {
+					store.close();
+					if (options.record !== false) removeUiFile(file, process.pid);
+					resolve();
+				});
+				server.closeAllConnections();
+			});
+			return closed;
+		}
+	};
+};
+export { openMcp as a, refused as c, uiFilePath as i, startServer as n, tool as o, runningServer as r, answer as s, DEFAULT_PORT as t };