@krapht/ork 0.2.0 → 0.4.0

package/dist/src-CpDKIulI.mjs

@@ -0,0 +1,3118 @@
+import { $ as resumable, An as parseWorkflow, B as unlinkNodes, Dn as newWorkflowText, Dt as nodeSays, En as applyEdits, Ft as runGh, G as tellLiveRun, H as requestContinue, In as expandEdge, It as sendPost, L as linkNodes, Nt as DISCUSSIONS, On as readDocument, Pn as EdgeInputSchema, Pt as planPost, Q as detachResume, Rn as NodeSchema, Tn as WorkflowEditSchema, U as requestPause, W as requestStop, _n as inside, _t as walkChecks, at as explainWorkflowText, d as runningRunIds, dn as placeFiles, dt as runStatus, f as runningScript, fn as placeFor, ft as runTree, g as triggersReport, gn as workflowDirOf, gt as checkWorkflowText, it as followEvents, kn as renderJsonSchema, l as planUpgrade, lt as liveStatus, mn as runDirOf, mt as processAlive, o as limitsReport, on as loadAgents, p as detectInstaller, qt as readCondition, r as capsHere, rt as detachRun, u as releaseNotes, ut as pausedOf, vt as walkSummary, wn as skillsIn, yn as LESSON_CAP_TOKENS } from "./src-CGqMati3.mjs";
+import { D as placeOf$1, E as lessonPlaceOf, O as feedbackActions, S as previewPost, T as acceptItem, _ as answerDecision, a as registryShown, c as checkDue, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, k as openFixRun, l as fetchLatest, m as updateCachePath, o as updateSwitchOff, p as refreshUpdateCache, s as runInstall, u as newerVersion, v as pendingDecisions, w as recordNote, y as builtinProblem } from "./__build_info__-CtSVVuZE.mjs";
+import { n as newRunId, t as findRun } from "./find-DptmbhGd.mjs";
+import { c as openStore, l as storePath, s as nodeOf } from "./output-CXSJO00X.mjs";
+import { n as usageReport } from "./report-DK4LGqwF.mjs";
+import { a as planClean, i as keyOf, o as stepActs, r as cleanStep, s as stepPrunes, t as applyClean } from "./clean-Dcr807be.mjs";
+import { a as readWorktrees, c as planLine, i as projectHead, l as removeRefusal, n as lostWork, o as labelOf, r as planRemove, s as mergeStateOf, t as applyRemove, u as stateParts } from "./remove-AwaMMaHf.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, randomUUID, 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-context.ts
+const CONTEXT_API = {
+	runContext: {
+		method: "GET",
+		path: "/api/runs/:id/nodes/:node/context"
+	},
+	builderContext: {
+		method: "GET",
+		path: "/api/projects/:id/builder/:name/nodes/:node/context"
+	}
+};
+// ../server/src/contract-feedback.ts
+const NoteSchema = z.strictObject({
+	/** Its first line is the title. */
+	text: z.string().min(1),
+	/** A node that ran in the run; the run itself without one. */
+	node: z.string().min(1).optional(),
+	kind: z.string().min(1).optional(),
+	severity: z.string().min(1).optional(),
+	rating: z.string().min(1).optional()
+});
+/** Dismissing an item, or restoring a dismissed one as `new`. */
+const FeedbackStatusSchema = z.strictObject({ status: z.enum(["dismissed", "new"]) });
+const AcceptSchema = z.strictObject({
+	/** Also write it into its workflow's lessons file. */
+	lesson: z.boolean(),
+	/** The lesson's words; the item's title by default. */
+	text: z.string().min(1).optional(),
+	/** Which workflow's lessons, when it was seen in more than one. */
+	workflow: z.string().min(1).optional()
+});
+const ApplySchema = z.strictObject({ driver: z.enum(["sdk", "cli"]).optional() });
+const PublishPreviewSchema = z.strictObject({ 
+/** Also hide the repositories' and workflows' names. */
+hideNames: z.boolean() });
+const PublishSchema = z.strictObject({
+	hideNames: z.boolean(),
+	/** The preview's digest: what the person saw, so nothing else is sent. */
+	digest: z.string().min(1)
+});
+const FEEDBACK_API = {
+	note: {
+		method: "POST",
+		path: "/api/runs/:id/notes",
+		body: NoteSchema
+	},
+	feedbackItems: {
+		method: "GET",
+		path: "/api/feedback"
+	},
+	feedbackItem: {
+		method: "GET",
+		path: "/api/feedback/:id"
+	},
+	feedbackStatus: {
+		method: "POST",
+		path: "/api/feedback/:id/status",
+		body: FeedbackStatusSchema
+	},
+	accept: {
+		method: "POST",
+		path: "/api/feedback/:id/accept",
+		body: AcceptSchema
+	},
+	apply: {
+		method: "POST",
+		path: "/api/feedback/:id/apply",
+		body: ApplySchema
+	},
+	publishPreview: {
+		method: "POST",
+		path: "/api/feedback/:id/publish/preview",
+		body: PublishPreviewSchema
+	},
+	publish: {
+		method: "POST",
+		path: "/api/feedback/:id/publish",
+		body: PublishSchema
+	},
+	split: {
+		method: "POST",
+		path: "/api/feedback/:id/split"
+	}
+};
+// ../server/src/contract-links.ts
+/**
+* @file The routes that link two nodes of live runs (RFC-003): list, link and
+*   end a link. It imports only `zod`, so a browser bundle can use it.
+*/
+/** 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 LINKS_API = {
+	links: {
+		method: "GET",
+		path: "/api/links",
+		query: z.strictObject({ run: z.string().min(1).optional() })
+	},
+	link: {
+		method: "POST",
+		path: "/api/links",
+		body: LinkSchema
+	},
+	unlink: {
+		method: "POST",
+		path: "/api/links/end",
+		body: UnlinkSchema
+	}
+};
+const UPDATE_API = {
+	version: {
+		method: "GET",
+		path: "/api/version"
+	},
+	upgradePlan: {
+		method: "POST",
+		path: "/api/upgrade/plan"
+	},
+	upgrade: {
+		method: "POST",
+		path: "/api/upgrade",
+		body: z.strictObject({ 
+		/** The plan the person read; the server runs its own argv, never a sent one. */
+planId: z.string().min(1) })
+	},
+	restart: {
+		method: "POST",
+		path: "/api/restart"
+	}
+};
+// ../server/src/contract-worktrees.ts
+const Root = z.string().min(1);
+const WorktreesQuerySchema = z.strictObject({ 
+/** A project's root; every project Ork knows without one. */
+project: Root.optional() });
+const RemovePlanSchema = z.strictObject({
+	project: Root,
+	/** The item's branch, or a detached worktree's path. */
+	key: z.string().min(1),
+	/** Also delete the branch (implied for a branch with no worktree). */
+	deleteBranch: z.boolean()
+});
+const RemoveSchema = RemovePlanSchema.extend({
+	/** The plan needs it: removing loses work the person was shown. */
+	force: z.boolean(),
+	/** The plan's digest: what the person saw, so nothing else goes. */
+	digest: z.string().min(1)
+});
+const CleanPlanSchema = z.strictObject({
+	project: Root.optional(),
+	/** Also delete the merged branches (`--branches`). */
+	branches: z.boolean()
+});
+const CleanSchema = CleanPlanSchema.extend({ digest: z.string().min(1) });
+const WORKTREES_API = {
+	worktrees: {
+		method: "GET",
+		path: "/api/worktrees",
+		query: WorktreesQuerySchema
+	},
+	worktreeRemovePlan: {
+		method: "POST",
+		path: "/api/worktrees/remove/plan",
+		body: RemovePlanSchema
+	},
+	worktreeRemove: {
+		method: "POST",
+		path: "/api/worktrees/remove",
+		body: RemoveSchema
+	},
+	worktreesCleanPlan: {
+		method: "POST",
+		path: "/api/worktrees/clean/plan",
+		body: CleanPlanSchema
+	},
+	worktreesClean: {
+		method: "POST",
+		path: "/api/worktrees/clean",
+		body: CleanSchema
+	}
+};
+// ../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)
+});
+/** 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,
+	...CONTEXT_API,
+	...FEEDBACK_API,
+	...WORKTREES_API,
+	...UPDATE_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_API
+};
+/** 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`, `decisions`, `version`, each when it changes; `?project=` keeps
+	* one. `upgrade`: the upgrade's output, then `end` (contract-update.ts).
+	*/
+	overview: "/api/stream",
+	upgrade: "/api/upgrade/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/streams-contract-and-security.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$1 = (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$1(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$1(`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$1(z.prettifyError(parsed.error)));
+		}
+	};
+};
+// ../server/src/write-routes.ts
+/**
+* @file The API's write routes (specs/server/api.md): 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$1(`No registered project \`${key}\`.`)
+	};
+	if (args.workflow === void 0 === (args.text === void 0)) return {
+		ok: false,
+		answer: refused$1("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$1(`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/api.md). 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/api.md): 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$1(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
+		})))
+	];
+};
+const NOT_HERE = "This server was not started by `ork ui`.";
+/** Asks the registry when the daily check is due; never throws. */
+const checkIfDue = async (file, options) => {
+	try {
+		const now = /* @__PURE__ */ new Date();
+		const cache = readUpdateCache(file);
+		if (!checkDue(cache, now)) return false;
+		writeUpdateCache(file, {
+			...cache,
+			checkedAt: now.toISOString()
+		});
+		const registry = registryOf(options.env ?? process.env);
+		await refreshUpdateCache(file, options.name, now, {
+			...registry === void 0 ? {} : { registry },
+			...options.fetch === void 0 ? {} : { fetch: options.fetch }
+		});
+		return true;
+	} catch {
+		return false;
+	}
+};
+const createUpdates = (input) => {
+	const { version, options } = input;
+	const file = updateCachePath(input.home);
+	const env = options?.env ?? process.env;
+	const switched = options === void 0 ? null : updateSwitchOff(env);
+	const reason = options === void 0 ? NOT_HERE : switched === null ? null : `${switched} is set`;
+	let record = null;
+	let job = null;
+	const read = () => {
+		const at = Date.now();
+		const every = options?.readEveryMs ?? 6e4;
+		if (record === null || at - record.at >= every) record = {
+			cache: readUpdateCache(file),
+			at
+		};
+		return record.cache;
+	};
+	let timer;
+	if (options !== void 0 && reason === null) {
+		const due = () => {
+			checkIfDue(file, options).then((asked) => {
+				if (asked) record = null;
+				return asked;
+			});
+		};
+		due();
+		timer = setInterval(due, options.checkEveryMs ?? 36e5);
+		timer.unref();
+	}
+	return {
+		info: () => {
+			const cache = read();
+			const newer = options === void 0 || reason !== null ? null : newerVersion(cache, version);
+			const registry = registryOf(env);
+			return {
+				current: version,
+				latest: cache?.latest ?? null,
+				newer,
+				checkedAt: cache?.checkedAt ?? null,
+				releaseNotes: newer === null || options === void 0 ? null : releaseNotes(options.name, newer),
+				check: reason === null ? { on: true } : {
+					on: false,
+					reason
+				},
+				registry: registry === void 0 ? null : registryShown(registry),
+				job: job?.view() ?? null
+			};
+		},
+		options,
+		file,
+		forget: () => {
+			record = null;
+		},
+		job: () => job,
+		setJob: (next) => {
+			job = next;
+		},
+		close: () => {
+			clearInterval(timer);
+		}
+	};
+};
+// ../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 },
+		updates: createUpdates({ version: options.version })
+	};
+	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/context-routes.ts
+/**
+* @file The context inspector's routes: what one node's session would load,
+*   planned without writing anything. A run's node is planned from the run's
+*   workflow file as it is now, naming each file behind it that changed after
+*   the run started; a builder's node from the draft, else the file, so an edit
+*   shows at once.
+*/
+/** Whether `file` was written after `since`, an ISO time. */
+const changedAfter = (file, since) => {
+	try {
+		return statSync(file).mtimeMs > Date.parse(since);
+	} catch {
+		return false;
+	}
+};
+/** A file as the user knows it: in the project, under `~`, or whole. */
+const shownAs = (file, root, home) => {
+	const inside = (base) => {
+		const relative = path.relative(base, file);
+		return relative.startsWith("..") || path.isAbsolute(relative) ? void 0 : relative;
+	};
+	const inProject = inside(root);
+	if (inProject !== void 0) return inProject;
+	const inHome = inside(home);
+	return inHome === void 0 ? file : `~/${inHome}`;
+};
+const answerOf = (result, changedSinceStart) => result.ok ? {
+	planned: true,
+	explanation: result.explanation,
+	changedSinceStart
+} : {
+	planned: false,
+	why: result.error,
+	changedSinceStart
+};
+const contextRoutes = (context) => {
+	/** Where to plan: in `place`, when the project is registered. */
+	const where = (place) => ({
+		registered: context.store.projects(),
+		...context.home === void 0 ? {} : { home: context.home },
+		...place === void 0 ? {} : { place }
+	});
+	return {
+		runContext: ({ params }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const { file, startedAt, project } = found.run;
+			const home = context.home ?? homedir();
+			const text = readText(file);
+			if (text === void 0) return ok({
+				planned: false,
+				why: `The run's workflow file \`${file}\` is gone.`,
+				changedSinceStart: [shownAs(file, project, home)]
+			});
+			const result = explainWorkflowText(text, file, params.node, where(projectOf(context, project)));
+			const read = [file, ...result.ok ? result.sources : []];
+			return ok(answerOf(result, [...new Set(read)].filter((each) => changedAfter(each, startedAt)).map((each) => shownAs(each, project, home))));
+		},
+		builderContext: ({ params }) => {
+			const project = projectOf(context, params.id);
+			if (project === void 0) return fail(404, `No registered project \`${params.id}\`.`);
+			const problem = problemWith(project, params.name);
+			if (problem !== void 0) return fail(problem.refused, problem.error);
+			const file = fileOf(project, params.name);
+			const text = context.store.draft(project.id, params.name)?.text ?? readText(file);
+			if (text === void 0) {
+				const missing = notFound(project, params.name);
+				return fail(missing.refused, missing.error);
+			}
+			return ok(answerOf(explainWorkflowText(text, file, params.node, where(project)), []));
+		}
+	};
+};
+// ../server/src/feedback-apply.ts
+/**
+* @file Applying an item from the Feedback panel (ADR-059): the same checks as
+*   `ork feedback apply`, then that command started in the background with a
+*   run id picked here, so the Monitor can follow the run and its gate's keep
+*   or discard settles the item exactly as in a terminal.
+*/
+const BUILTIN = "ork:feedback-apply";
+/** Starts a run proposing a fix for `item`, or says why it can't. */
+const applyRoute = async (context, item, driver) => {
+	const { store } = context;
+	const allowed = feedbackActions(item, openFixRun(store, item)).apply;
+	if (!allowed.ok) return fail(409, allowed.error);
+	const found = placeOf$1(store, item, void 0, store.projects());
+	if (!found.ok) return fail(409, found.error);
+	const { place } = found;
+	const problem = builtinProblem(place, BUILTIN);
+	if (problem !== void 0) return fail(409, problem);
+	const runId = newRunId(store);
+	const detached = await detachRun({
+		store,
+		runId,
+		args: [
+			"feedback",
+			"apply",
+			item.id,
+			"--run-id",
+			runId,
+			...driver === void 0 ? [] : ["--driver", driver]
+		],
+		cwd: place.root,
+		runDir: runDirOf(place, runId),
+		...context.script === void 0 ? {} : { script: context.script }
+	});
+	return detached.ok ? accepted({
+		runId,
+		root: place.root
+	}) : fail(400, detached.error || "The run did not start.");
+};
+// ../server/src/feedback-detail.ts
+/**
+* @file An item as the Feedback panel shows it: its records, which actions it
+*   allows (the rule `ork feedback` keeps too), where a lesson for each of its
+*   workflows would go and how big that file is, the project a fix would be
+*   proposed in, and the run proposing one now, if any.
+*/
+const detailOf = (store, item) => {
+	const registered = store.projects();
+	const fixRun = openFixRun(store, item);
+	const actions = feedbackActions(item, fixRun);
+	const found = placeOf$1(store, item, void 0, registered);
+	return {
+		item,
+		records: store.feedbackRecords(item.id),
+		actions,
+		lessons: item.target === "ork" ? [] : item.workflows.map((w) => lessonPlaceOf(store, item, w, registered)),
+		lessonCap: LESSON_CAP_TOKENS,
+		project: found.ok && item.target !== "ork" ? {
+			ok: true,
+			root: found.place.root
+		} : {
+			ok: false,
+			error: found.ok ? "It's about Ork itself." : found.error
+		},
+		...fixRun === void 0 ? {} : { fixRun }
+	};
+};
+// ../server/src/feedback-publish.ts
+/**
+* @file Publishing an `ork` item from the Feedback panel (ADR-059): the preview
+*   shows exactly what would be sent and where, with a digest of it; the
+*   publish makes the preview again and sends it only when its digest is the
+*   one the person saw, with their own `gh` login.
+*/
+const refused = (status, error) => ({
+	ok: false,
+	refusal: fail(status, error)
+});
+/** The preview of `item`'s post, and its digest, or why there's none. */
+const previewOf = async (context, item, hideNames) => {
+	const shown = previewPost(context.store, item, {
+		home: context.home ?? homedir(),
+		registered: context.store.projects(),
+		hideNames
+	});
+	if (!shown.ok) return refused(409, shown.error);
+	const planned = await planPost(shown.post, context.gh ?? runGh);
+	if (!planned.ok) return refused(400, planned.error);
+	const digest = createHash("sha256").update(JSON.stringify([shown.post, planned.plan])).digest("hex");
+	return {
+		ok: true,
+		preview: {
+			post: shown.post,
+			plan: planned.plan,
+			repo: `${DISCUSSIONS.owner}/${DISCUSSIONS.name}`,
+			digest
+		}
+	};
+};
+/** Sends `item`'s post when it's still the one previewed as `digest`. */
+const sendPublish = async (context, item, ask) => {
+	const previewed = await previewOf(context, item, ask.hideNames);
+	if (!previewed.ok) return previewed;
+	const { post, plan, digest } = previewed.preview;
+	if (digest !== ask.digest) return refused(409, "What would be sent changed after the preview, so nothing was sent: look at the preview again.");
+	const sent = await sendPost(post, plan, context.gh ?? runGh);
+	if (!sent.ok) return refused(400, sent.error);
+	context.store.setFeedbackStatus(item.id, "published");
+	return {
+		ok: true,
+		url: sent.url,
+		kind: sent.kind
+	};
+};
+// ../server/src/feedback-routes.ts
+/**
+* @file The feedback loop's routes (specs/feedback.md), through the same core
+*   functions as `ork feedback`: the items and an item's records; dismiss and
+*   restore; accept, maybe as a lesson; apply, which starts `ork feedback
+*   apply` in the background so its keep-or-discard ends the same way; publish
+*   after a preview, sending only what the preview showed; and a person's note
+*   on a run, or one node of it.
+*/
+/** The item `id` names (its fingerprint, or a group's member), or a 404. */
+const itemOf = (store, id) => {
+	const [item, other] = store.findFeedback(id);
+	return item === void 0 || other !== void 0 ? {
+		ok: false,
+		refusal: fail(404, `No feedback item ${id}.`)
+	} : {
+		ok: true,
+		item
+	};
+};
+/** The item as it is now, after a write. */
+const fresh = (store, item) => store.findFeedback(item.id)[0] ?? item;
+const feedbackRoutes = (context) => {
+	const { store } = context;
+	return {
+		note: ({ params, body }) => {
+			const found = runOf(context, params.id);
+			if (!found.ok) return found.refusal;
+			const noted = recordNote(store, found.run, body);
+			return noted.ok ? ok({ item: noted.item }) : fail(400, noted.error);
+		},
+		feedbackItems: () => ok(store.feedbackItems({ all: true })),
+		feedbackItem: ({ params }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			return ok(detailOf(store, found.item));
+		},
+		feedbackStatus: ({ params, body }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			const { item } = found;
+			if (body.status === "new" && item.status !== "dismissed") return fail(409, `${item.id.slice(0, 12)} isn't dismissed, so there's nothing to restore.`);
+			store.setFeedbackStatus(item.id, body.status);
+			return ok(fresh(store, item));
+		},
+		accept: ({ params, body }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			const accepted = acceptItem(store, found.item, body, context.store.projects());
+			if (!accepted.ok) return fail(409, accepted.error);
+			return ok({
+				item: fresh(store, found.item),
+				...accepted.lesson === void 0 ? {} : { lesson: accepted.lesson }
+			});
+		},
+		apply: ({ params, body }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			return applyRoute(context, found.item, body.driver);
+		},
+		publishPreview: async ({ params, body }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			const previewed = await previewOf(context, found.item, body.hideNames);
+			return previewed.ok ? ok(previewed.preview) : previewed.refusal;
+		},
+		publish: async ({ params, body }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			const sent = await sendPublish(context, found.item, body);
+			return sent.ok ? ok({
+				item: fresh(store, found.item),
+				url: sent.url,
+				kind: sent.kind
+			}) : sent.refusal;
+		},
+		split: ({ params }) => {
+			const found = itemOf(store, params.id);
+			if (!found.ok) return found.refusal;
+			if (found.item.merged.length === 0) return fail(409, `Nothing was merged into ${found.item.id.slice(0, 12)}, so there's nothing to split.`);
+			return ok({ moved: store.splitFeedback(found.item.id) });
+		}
+	};
+};
+const ANSI = /\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)|\u001B[@-Z\\-_]/gu;
+/** A line as a terminal would end up showing it. */
+const plainLine = (raw) => (raw.replaceAll(ANSI, "").split("\r").findLast((part) => part !== "") ?? "").replaceAll(/\s+$/gu, "");
+const startJob = (latest, argv, install, onChange) => {
+	const job = {
+		id: randomUUID(),
+		state: "running",
+		latest,
+		command: [...argv],
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const lines = [];
+	const partial = {
+		stdout: "",
+		stderr: ""
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	let seq = 0;
+	let ended = null;
+	const tell = (event) => {
+		for (const listener of listeners) listener(event);
+	};
+	const keep = (stream, raw) => {
+		seq += 1;
+		const line = {
+			seq,
+			stream,
+			text: plainLine(raw)
+		};
+		lines.push(line);
+		if (lines.length > 2e3) lines.shift();
+		tell({
+			kind: "output",
+			line
+		});
+	};
+	const output = (stream, text) => {
+		const parts = `${partial[stream]}${text}`.split("\n");
+		partial[stream] = parts.pop() ?? "";
+		for (const part of parts) keep(stream, part);
+	};
+	const finished = install(argv, output).catch((error) => {
+		keep("stderr", error instanceof Error ? error.message : String(error));
+		return 1;
+	});
+	const finish = async () => {
+		const code = await finished;
+		for (const stream of ["stdout", "stderr"]) {
+			if (partial[stream] !== "") keep(stream, partial[stream]);
+			partial[stream] = "";
+		}
+		const state = code === 0 ? "succeeded" : "failed";
+		Object.assign(job, {
+			state,
+			code,
+			endedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		ended = {
+			state,
+			code,
+			version: latest
+		};
+		onChange();
+		tell({
+			kind: "end",
+			end: ended
+		});
+	};
+	return {
+		view: () => ({
+			...job,
+			command: [...job.command]
+		}),
+		linesAfter: (after) => ({
+			lines: lines.filter((line) => line.seq > after),
+			dropped: (lines[0]?.seq ?? 1) > after + 1
+		}),
+		end: () => ended,
+		done: finish(),
+		listen: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+};
+// ../server/src/upgrade-plan.ts
+/**
+* @file The upgrade `ork ui` offers, which is `ork upgrade`'s
+*   (specs/cli/updates.md): the plan asks the registry now and records the
+*   answer as `ork upgrade` does, then gives core's plan with an id; running it
+*   rebuilds the plan and runs the server's own command only when the id the
+*   person read still matches, so the page never sends a command.
+*/
+/** How long the plan waits on the registry, as `ork upgrade`. */
+const ASK_TIMEOUT_MS = 15e3;
+const NO_UPGRADE = "This server can't upgrade Ork; run `ork upgrade` in a terminal.";
+const BUSY = "An upgrade is already running.";
+const UNREACHABLE = "Could not reach the npm registry to look for a new version. Nothing was run.";
+const ADVICE = "Ork runs only a package manager's own command from here; this one is yours to run.";
+/** Records what the registry said, as `ork upgrade` does. */
+const remember = (file, latest, notified) => {
+	try {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		writeUpdateCache(file, {
+			...readUpdateCache(file),
+			checkedAt: now,
+			latest,
+			...notified ? { notified: {
+				version: latest,
+				at: now
+			} } : {}
+		});
+	} catch {}
+};
+const idOf = (parts) => createHash("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 16);
+/** Asks the registry now and says what an upgrade would do. */
+const askPlan = async (context) => {
+	const { updates, version: current } = context;
+	const { options } = updates;
+	if (options === void 0) return null;
+	const registry = registryOf(options.env ?? process.env);
+	const latest = await fetchLatest(options.name, {
+		...registry === void 0 ? {} : { registry },
+		...options.fetch === void 0 ? {} : { fetch: options.fetch },
+		timeoutMs: ASK_TIMEOUT_MS
+	});
+	const script = options.script ?? runningScript();
+	const plan = planUpgrade({
+		name: options.name,
+		current,
+		latest,
+		script
+	});
+	if (plan.kind === "unreachable") return plan;
+	if (latest !== null) remember(updates.file, latest, plan.kind !== "latest");
+	updates.forget();
+	if (plan.kind === "latest") return {
+		kind: "latest",
+		current
+	};
+	const shared = {
+		current,
+		latest: plan.latest,
+		releaseNotes: releaseNotes(options.name, plan.latest),
+		running: runningRunIds(context.store)
+	};
+	if (plan.kind === "command") {
+		const command = [...plan.argv];
+		const { id, label } = plan.installer;
+		return {
+			kind: "command",
+			planId: idOf([
+				plan.kind,
+				plan.latest,
+				id,
+				command
+			]),
+			...shared,
+			installer: {
+				id,
+				label
+			},
+			command
+		};
+	}
+	const installer = detectInstaller(script);
+	return {
+		kind: "advice",
+		planId: idOf([
+			plan.kind,
+			plan.latest,
+			installer?.id,
+			plan.text
+		]),
+		...shared,
+		installer: installer === void 0 ? null : {
+			id: installer.id,
+			label: installer.label
+		},
+		text: plan.text,
+		words: plan.words,
+		commands: [...plan.commands]
+	};
+};
+const changed = (plan) => {
+	return `The plan changed since you read it: ${plan.kind === "latest" ? `Ork ${plan.current} is the latest version now` : `Ork ${plan.latest} is out now`}. Read it again before upgrading.`;
+};
+const running = (context) => context.updates.job()?.view().state === "running";
+/** Runs the plan the person read, when it is still the plan. */
+const startUpgrade = async (context, planId) => {
+	const { updates } = context;
+	const { options } = updates;
+	if (options === void 0) return fail(400, NO_UPGRADE);
+	if (running(context)) return fail(409, BUSY);
+	const plan = await askPlan(context);
+	if (running(context)) return fail(409, BUSY);
+	if (plan === null || plan.kind === "unreachable") return fail(400, UNREACHABLE);
+	if (plan.kind === "latest" || plan.planId !== planId) return fail(409, changed(plan));
+	if (plan.kind === "advice") return fail(400, ADVICE);
+	const job = startJob(plan.latest, plan.command, options.install ?? runInstall, updates.forget);
+	updates.setJob(job);
+	return accepted({ job: job.view() });
+};
+const CANNOT_RESTART = "This server can't restart itself; stop it and run `ork ui`.";
+const RESTART_BUSY = "An upgrade is running; restart `ork ui` once it has ended.";
+const updateRoutes = (context, port) => ({
+	version: () => ok(context.updates.info()),
+	upgradePlan: async () => {
+		const plan = await askPlan(context);
+		return plan === null ? fail(400, NO_UPGRADE) : ok(plan);
+	},
+	upgrade: ({ body }) => startUpgrade(context, body.planId),
+	restart: () => {
+		const { restart } = context;
+		if (restart === void 0) return fail(400, CANNOT_RESTART);
+		if (context.updates.job()?.view().state === "running") return fail(409, RESTART_BUSY);
+		setTimeout(restart, 100);
+		return accepted({
+			port: port(),
+			pid: context.pid
+		});
+	}
+});
+// ../server/src/worktrees-read.ts
+/**
+* @file What the Worktrees panel reads, through the same core functions as `ork
+*   worktrees`: the projects Ork knows (registered, or a stored run's), each
+*   one's items with core's words and what Remove… allows, and the plan Clean
+*   merged… would carry out, with a digest of it. A project git can't read
+*   comes back with its error, never as a failed request.
+*/
+/** Every project Ork knows, by name: registered ones, then runs' others. */
+const knownProjects = (context) => {
+	const names = new Map(context.store.projects().map((p) => [p.root, p.id]));
+	for (const run of context.store.runs()) if (!names.has(run.project)) names.set(run.project, path.basename(run.project) || run.project);
+	return [...names].map(([root, name]) => ({
+		root,
+		name
+	})).toSorted((a, b) => a.name.localeCompare(b.name));
+};
+/** The project `root` names, or all of them; only roots Ork knows. */
+const projectsFor = (context, root) => {
+	const known = knownProjects(context);
+	if (root === void 0) return {
+		ok: true,
+		projects: known
+	};
+	const found = known.filter((p) => p.root === root);
+	return found.length === 0 ? {
+		ok: false,
+		refusal: fail(404, `Ork doesn't know a project at ${root}.`)
+	} : {
+		ok: true,
+		projects: found
+	};
+};
+const failed = (known, error, fix) => ({
+	...known,
+	head: null,
+	error,
+	...fix === void 0 ? {} : { fix }
+});
+/** A project's items and runs still going, or why git couldn't read them. */
+const readProject = async (context, known) => {
+	if (!existsSync(known.root)) {
+		const registered = context.store.projects().find((p) => p.root === known.root);
+		return failed(known, `its folder ${known.root} is gone.`, registered === void 0 ? void 0 : `ork projects move ${registered.id} <new path>`);
+	}
+	const head = await projectHead(known.root);
+	if (!head.ok) return failed(known, "Not in a git repository with a commit.");
+	try {
+		const worktrees = await readWorktrees(context.store, known.root);
+		return {
+			...known,
+			head: head.branch,
+			worktrees
+		};
+	} catch (error) {
+		return failed(known, error instanceof Error ? error.message : String(error));
+	}
+};
+const runKnown = (context, id) => context.store.lookup(id).some((run) => run.id === id);
+const rowOf = (context, item, live) => {
+	const going = live.has(item.runId);
+	const refusal = removeRefusal(item, going);
+	const keeps = item.merged ? cleanStep(item, {
+		branches: false,
+		force: false,
+		live
+	}).skip : void 0;
+	return {
+		...item,
+		key: keyOf(item),
+		label: labelOf(item),
+		state: mergeStateOf(item),
+		parts: stateParts(item),
+		run: {
+			known: runKnown(context, item.runId),
+			live: going
+		},
+		...keeps === void 0 ? {} : { cleanKeeps: keeps },
+		remove: {
+			label: item.path === null ? "Delete branch…" : "Remove…",
+			...refusal === void 0 ? {} : { refusal }
+		}
+	};
+};
+/** A read project as the list shows it. */
+const listed = (context, read) => {
+	const { worktrees, ...rest } = read;
+	const live = worktrees?.live ?? /* @__PURE__ */ new Set();
+	return {
+		...rest,
+		items: (worktrees?.items ?? []).map((item) => rowOf(context, item, live))
+	};
+};
+/** Clean merged's plan for a read project: never forced. */
+const cleanStepsOf = (read, branches) => read.worktrees === void 0 ? [] : planClean(read.worktrees.items, { merged: true }, {
+	branches,
+	force: false,
+	live: read.worktrees.live
+});
+/** A read project's clean plan as the dialog shows it. */
+const cleanPlanOf = (read, steps) => ({
+	root: read.root,
+	name: read.name,
+	head: read.head,
+	...read.error === void 0 ? {} : { error: read.error },
+	steps: steps.map((step) => ({
+		key: keyOf(step.item),
+		line: planLine(step),
+		removeWorktree: step.removeWorktree,
+		deleteBranch: step.deleteBranch,
+		prunes: stepPrunes(step),
+		...step.skip === void 0 ? {} : { skip: step.skip }
+	}))
+});
+/** What a person was shown, as a digest an act hands back. */
+const digestOf = (shown) => createHash("sha256").update(JSON.stringify(shown)).digest("hex");
+// ../server/src/worktrees-remove.ts
+/**
+* @file Remove… for one item, the twin of `ork worktrees remove`: the plan by
+*   core's rule with what it would lose, as git prints it, and a digest of
+*   both; then the removal, which plans again and goes ahead only when the
+*   digest is the one the person saw, and forces only a plan that needed it.
+*   What to remove is resolved from a fresh listing, never a path sent in.
+*/
+/** How many of git's lines a well shows; the rest are counted. */
+const SHOWN_LINES = 20;
+const firstOf = (all) => all.slice(0, SHOWN_LINES);
+const moreOf = (all) => Math.max(0, all.length - SHOWN_LINES);
+/** One item's remove plan, as the dialog shows it, or why there's none. */
+const removePlanOf = async (context, ask) => {
+	const found = projectsFor(context, ask.project);
+	if (!found.ok) return found;
+	const [known] = found.projects;
+	if (known === void 0) return {
+		ok: false,
+		refusal: fail(404, "No project.")
+	};
+	const read = await readProject(context, known);
+	if (read.worktrees === void 0) {
+		const why = `Could not read ${known.name}'s worktrees: ${read.error ?? ""}`;
+		return {
+			ok: false,
+			refusal: fail(400, why)
+		};
+	}
+	const planned = planRemove(read.worktrees, ask.key, ask.deleteBranch);
+	if (!planned.ok) return {
+		ok: false,
+		refusal: fail(planned.gone ? 404 : 400, planned.error)
+	};
+	const { plan } = planned;
+	const lost = await lostWork(known.root, plan);
+	const losing = {
+		changes: firstOf(lost.changes),
+		commits: firstOf(lost.commits),
+		commitsOn: lost.commitsOn,
+		more: {
+			changes: moreOf(lost.changes),
+			commits: moreOf(lost.commits)
+		}
+	};
+	const { step } = plan;
+	return {
+		ok: true,
+		known,
+		plan,
+		answer: {
+			parts: stateParts(step.item, read.head ?? void 0),
+			merged: step.item.merged,
+			ahead: step.item.ahead,
+			line: planLine(step),
+			removeWorktree: step.removeWorktree,
+			deleteBranch: step.deleteBranch,
+			prunes: stepPrunes(step) && !step.removeWorktree,
+			force: plan.force,
+			losing,
+			digest: digestOf({
+				step,
+				force: plan.force,
+				lost
+			})
+		}
+	};
+};
+const CHANGED = "It changed since you read it. Read it again before removing.";
+/** Removes the item when its plan is still the one shown as `digest`. */
+const removeIt = async (context, ask, busy) => {
+	if (busy.has(ask.project)) {
+		const name = projectsFor(context, ask.project);
+		const called = name.ok ? name.projects[0]?.name ?? ask.project : ask.project;
+		return {
+			ok: false,
+			refusal: fail(409, `A remove or clean is already running in ${called}.`)
+		};
+	}
+	busy.add(ask.project);
+	try {
+		const planned = await removePlanOf(context, ask);
+		if (!planned.ok) return planned;
+		if (planned.answer.digest !== ask.digest) return {
+			ok: false,
+			refusal: fail(409, CHANGED)
+		};
+		if (planned.plan.force && !ask.force) return {
+			ok: false,
+			refusal: fail(400, "That loses work: confirm what's lost first.")
+		};
+		const done = [];
+		try {
+			await applyRemove(planned.known.root, planned.plan, done);
+		} catch (error) {
+			const why = error instanceof Error ? error.message : String(error);
+			return {
+				ok: false,
+				refusal: fail(400, why)
+			};
+		}
+		return {
+			ok: true,
+			done
+		};
+	} finally {
+		busy.delete(ask.project);
+	}
+};
+// ../server/src/worktrees-routes.ts
+/**
+* @file The Worktrees panel's routes (specs/worktrees.md), through the same
+*   core functions as `ork worktrees`: the list for every project Ork knows
+*   (read in parallel, a project git can't read carrying its error), Remove…
+*   (worktrees-remove.ts), and Clean merged…, which only ever cleans what's
+*   merged, never forced, and goes ahead only when its plan's digest is the one
+*   the person saw. A project takes one write at a time.
+*/
+const PLAN_CHANGED = "The plan changed since you read it. Read it again before cleaning.";
+/** Carries out one project's part of a clean; what it did, and where it stopped. */
+const cleanOne = async (read, branches) => {
+	const done = [];
+	const acting = cleanStepsOf(read, branches).filter((step) => stepActs(step));
+	try {
+		if (acting.length > 0) await applyClean(read.root, acting, false, done);
+		return {
+			root: read.root,
+			name: read.name,
+			done
+		};
+	} catch (error) {
+		const why = error instanceof Error ? error.message : String(error);
+		return {
+			root: read.root,
+			name: read.name,
+			done,
+			error: why
+		};
+	}
+};
+const worktreesRoutes = (context) => {
+	/** The projects a remove or clean is writing to now. */
+	const busy = /* @__PURE__ */ new Set();
+	const readAll = async (project) => {
+		const found = projectsFor(context, project);
+		if (!found.ok) return found;
+		return {
+			ok: true,
+			reads: await Promise.all(found.projects.map((known) => readProject(context, known)))
+		};
+	};
+	const cleanPlan = async (body) => {
+		const all = await readAll(body.project);
+		if (!all.ok) return all;
+		const projects = all.reads.map((read) => cleanPlanOf(read, cleanStepsOf(read, body.branches)));
+		return {
+			ok: true,
+			reads: all.reads,
+			projects,
+			digest: digestOf(projects)
+		};
+	};
+	return {
+		worktrees: async ({ query }) => {
+			const all = await readAll(query.project);
+			if (!all.ok) return all.refusal;
+			return ok({ projects: all.reads.map((read) => listed(context, read)) });
+		},
+		worktreeRemovePlan: async ({ body }) => {
+			const planned = await removePlanOf(context, body);
+			return planned.ok ? ok(planned.answer) : planned.refusal;
+		},
+		worktreeRemove: async ({ body }) => {
+			const removed = await removeIt(context, body, busy);
+			return removed.ok ? ok({ done: removed.done }) : removed.refusal;
+		},
+		worktreesCleanPlan: async ({ body }) => {
+			const planned = await cleanPlan(body);
+			if (!planned.ok) return planned.refusal;
+			return ok({
+				projects: planned.projects,
+				digest: planned.digest
+			});
+		},
+		worktreesClean: async ({ body }) => {
+			const taken = projectsFor(context, body.project);
+			if (!taken.ok) return taken.refusal;
+			const held = taken.projects.find((p) => busy.has(p.root));
+			if (held !== void 0) return fail(409, `A remove or clean is already running in ${held.name}.`);
+			const roots = taken.projects.map((p) => p.root);
+			for (const root of roots) busy.add(root);
+			try {
+				const planned = await cleanPlan(body);
+				if (!planned.ok) return planned.refusal;
+				if (planned.digest !== body.digest) return fail(409, PLAN_CHANGED);
+				const projects = [];
+				for (const read of planned.reads) projects.push(await cleanOne(read, body.branches));
+				return ok({ projects });
+			} finally {
+				for (const root of roots) busy.delete(root);
+			}
+		}
+	};
+};
+// ../server/src/api-routes.ts
+/** @file Every JSON route's handler, in one place. */
+const apiRoutes = (context, port) => ({
+	...readRoutes(context),
+	...writeRoutes(context),
+	...builderRoutes(context),
+	...contextRoutes(context),
+	...feedbackRoutes(context),
+	...worktreesRoutes(context),
+	...updateRoutes(context, port)
+});
+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: "",
+		version: ""
+	};
+	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],
+			["version", context.updates.info()]
+		]) {
+			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/upgrade-stream.ts
+const NO_JOB = "No upgrade has run since `ork ui` started.";
+const upgradeStream = (context, req, res, url, shutdown) => {
+	const job = context.updates.job();
+	if (job === null) {
+		sendError(res, 404, NO_JOB);
+		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 { lines, dropped } = job.linesAfter(after);
+	if (dropped) {
+		const note = {
+			seq: (lines[0]?.seq ?? after + 1) - 1,
+			stream: "stderr",
+			text: "Earlier lines dropped."
+		};
+		stream.send("output", note);
+	}
+	for (const line of lines) stream.send("output", line, line.seq);
+	const ended = job.end();
+	if (ended !== null) {
+		stream.send("end", ended);
+		stream.close();
+		return;
+	}
+	const stop = job.listen((event) => {
+		if (event.kind === "output") {
+			stream.send("output", event.line, event.line.seq);
+			return;
+		}
+		stream.send("end", event.end);
+		stream.close();
+	});
+	stream.signal.addEventListener("abort", stop);
+	shutdown.addEventListener("abort", () => {
+		stream.close();
+	}, { signal: stream.signal });
+};
+// ../server/src/dispatch.ts
+const RUN_STREAM = compilePath(STREAMS.run);
+const createDispatch = (context, access) => {
+	const handlers = apiRoutes(context, access.port);
+	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 (method === "GET" && url.pathname === STREAMS.upgrade) {
+			upgradeStream(context, req, 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 updates = createUpdates({
+		version: options.version,
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.update === void 0 ? {} : { options: options.update }
+	});
+	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 },
+		...options.gh === void 0 ? {} : { gh: options.gh },
+		updates,
+		...options.restart === void 0 ? {} : { restart: options.restart }
+	};
+	const token = options.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) {
+		updates.close();
+		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,
+		upgrading: () => {
+			const job = updates.job();
+			return job === null || job.end() !== null ? null : job.done;
+		},
+		close: () => {
+			closed ??= new Promise((resolve) => {
+				shutdown.abort();
+				updates.close();
+				server.close(() => {
+					store.close();
+					if (options.record !== false) removeUiFile(file, process.pid);
+					resolve();
+				});
+				server.closeAllConnections();
+			});
+			return closed;
+		}
+	};
+};
+export { openMcp as a, refused$1 as c, uiFilePath as i, newToken as l, startServer as n, tool as o, runningServer as r, answer as s, DEFAULT_PORT as t };