@krapht/ork 0.3.0 → 0.4.0

package/dist/{src-D5ruZFgD.mjs → src-CpDKIulI.mjs}

@@ -1,12 +1,14 @@
-import { B as requestContinue, F as linkNodes, H as requestStop, Kt as loadAgents, Nt as readCondition, Qt as placeFor, R as unlinkNodes, Sn as NodeSchema, U as tellLiveRun, V as requestPause, X as detachResume, Z as resumable, Zt as placeFiles, at as processAlive, bn as expandEdge, cn as skillsIn, ct as checkWorkflowText, d as triggersReport, dn as newWorkflowText, en as runDirOf, fn as readDocument, it as pausedOf, ln as WorkflowEditSchema, lt as walkChecks, mn as parseWorkflow, nn as workflowDirOf, nt as followEvents, o as limitsReport, ot as runStatus, pn as renderJsonSchema, r as capsHere, rn as inside, rt as liveStatus, st as runTree, tt as detachRun, un as applyEdits, ut as walkSummary, vn as EdgeInputSchema, yt as nodeSays } from "./src-Cz1yOUTg.mjs";
-import { a as pendingDecisions, i as answerDecision, r as nodeSession } from "./__build_info__-CXXMLvjt.mjs";
-import { n as newRunId, t as findRun } from "./find-BcvhT6UN.mjs";
-import { c as openStore, l as storePath, s as nodeOf } from "./output-Q2EdeVUt.mjs";
+import { $ 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, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
 import { createServer } from "node:http";
 // ../core/src/store/activity.ts
@@ -133,6 +135,194 @@ const BUILDER_API = {
 		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();
@@ -179,17 +369,6 @@ const MessageSchema = z.strictObject({
 	node: z.string().min(1),
 	body: z.string().min(1)
 });
-/** Two nodes of live runs, each `<run>/<node>` (RFC-003). */
-const LinkSchema = z.strictObject({
-	a: z.string().min(3),
-	b: z.string().min(3),
-	maxMessages: z.number().int().positive().optional()
-});
-const UnlinkSchema = z.strictObject({
-	a: z.string().min(3),
-	b: z.string().min(3)
-});
-const LinksQuerySchema = z.strictObject({ run: z.string().min(1).optional() });
 /** Pause, continue or stop: the whole run, or `node` alone (ADR-041). */
 const ControlSchema = z.strictObject({ node: z.string().min(1).optional() });
 /** Every JSON route; the two event streams are in {@link STREAMS}. */
@@ -199,6 +378,10 @@ const API = {
 		path: "/api/health"
 	},
 	...BUILDER_API,
+	...CONTEXT_API,
+	...FEEDBACK_API,
+	...WORKTREES_API,
+	...UPDATE_API,
 	projects: {
 		method: "GET",
 		path: "/api/projects"
@@ -282,21 +465,7 @@ const API = {
 		method: "GET",
 		path: "/api/triggers"
 	},
-	links: {
-		method: "GET",
-		path: "/api/links",
-		query: LinksQuerySchema
-	},
-	link: {
-		method: "POST",
-		path: "/api/links",
-		body: LinkSchema
-	},
-	unlink: {
-		method: "POST",
-		path: "/api/links/end",
-		body: UnlinkSchema
-	}
+	...LINKS_API
 };
 /** The Server-Sent Event streams, and the events each sends. */
 const STREAMS = {
@@ -305,8 +474,12 @@ const STREAMS = {
 	* `Last-Event-ID`, or `?after=`.
 	*/
 	run: "/api/runs/:id/stream",
-	/** `runs` and `decisions`, each when it changes; `?project=` keeps one. */
-	overview: "/api/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
 /**
@@ -361,8 +534,9 @@ const runGraph = (events, file) => {
 };
 // ../server/src/guards.ts
 /**
-* @file What the server lets in (ADR-039, specs/server.md#security): only its
-*   own loopback `Host` (against DNS rebinding); only with its token, from the
+* @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
@@ -683,14 +857,14 @@ const shrink = (value, longest = LONGEST) => {
 	return value;
 };
 const answer = (value) => ({ text: JSON.stringify(shrink(value)) });
-const refused = (error) => ({
+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(settled.error) : answer(then(settled.body));
+	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`. */
@@ -721,7 +895,7 @@ const formatPart = (nodeType) => {
 		}
 	});
 	const branch = branches.find((item) => typeOf(item) === nodeType);
-	return branch === void 0 ? refused(`No node type \`${nodeType}\`. The types are: ${types.map((type) => `\`${type}\``).join(", ")}.`) : { text: JSON.stringify(branch) };
+	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
 /**
@@ -738,13 +912,13 @@ const tool = (name, description, shape, run, options = {}) => {
 		readOnly: options.readOnly ?? true,
 		call: (args) => {
 			const parsed = schema.safeParse(args ?? {});
-			return Promise.resolve(parsed.success ? run(parsed.data) : refused(z.prettifyError(parsed.error)));
+			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.md#api): answer a decision; stop,
+* @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`,
@@ -882,11 +1056,11 @@ const textOf = (context, key, args) => {
 	const place = projectOf(context, key);
 	if (place === void 0) return {
 		ok: false,
-		answer: refused(`No registered project \`${key}\`.`)
+		answer: refused$1(`No registered project \`${key}\`.`)
 	};
 	if (args.workflow === void 0 === (args.text === void 0)) return {
 		ok: false,
-		answer: refused("Give either `workflow` (a name or path) or `text`.")
+		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");
@@ -900,7 +1074,7 @@ const textOf = (context, key, args) => {
 	const file = workflowFile(place, args.workflow ?? "");
 	return file === null ? {
 		ok: false,
-		answer: refused(`No workflow \`${args.workflow ?? ""}\` in \`${place.id}\`'s workflows or inside its root.`)
+		answer: refused$1(`No workflow \`${args.workflow ?? ""}\` in \`${place.id}\`'s workflows or inside its root.`)
 	} : {
 		ok: true,
 		text: readFileSync(file, "utf8"),
@@ -1282,7 +1456,7 @@ const saveDraft = (context, project, name, force) => {
 };
 // ../server/src/builder-routes.ts
 /**
-* @file The workflow builder's routes (RFC-008, specs/server.md#api). Each
+* @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.
 */
@@ -1383,7 +1557,7 @@ const projectWorkflows = (project) => {
 };
 // ../server/src/read-routes.ts
 /**
-* @file The API's read routes (specs/server.md#api): health, projects and a
+* @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`).
@@ -1498,7 +1672,7 @@ const mcpTools = (context) => {
 				...NO_QUERY,
 				params: { id: args.run }
 			});
-			if ("error" in view) return refused(view.error);
+			if ("error" in view) return refused$1(view.error);
 			const tree = read.tree({
 				...NO_QUERY,
 				params: { id: view.body.id }
@@ -1535,6 +1709,89 @@ const mcpTools = (context) => {
 		})))
 	];
 };
+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
@@ -1550,7 +1807,8 @@ const openMcp = (options) => {
 		pid: process.pid,
 		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		...options.home === void 0 ? {} : { home: options.home },
-		...options.script === void 0 ? {} : { script: options.script }
+		...options.script === void 0 ? {} : { script: options.script },
+		updates: createUpdates({ version: options.version })
 	};
 	return {
 		tools: [...mcpTools(context), ...actingTools(context, { start: options.start })],
@@ -1620,12 +1878,833 @@ const readAsset = (dir, pathname) => {
 		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) => ({
+const apiRoutes = (context, port) => ({
 	...readRoutes(context),
 	...writeRoutes(context),
-	...builderRoutes(context)
+	...builderRoutes(context),
+	...contextRoutes(context),
+	...feedbackRoutes(context),
+	...worktreesRoutes(context),
+	...updateRoutes(context, port)
 });
 const PLACEHOLDER_HTML = `<!doctype html>
 <html lang="en">
@@ -1780,7 +2859,8 @@ const overviewStream = (context, res, url, shutdown) => {
 	const stream = openEventStream(res);
 	const last = {
 		runs: "",
-		decisions: ""
+		decisions: "",
+		version: ""
 	};
 	const tick = () => {
 		const filter = root === void 0 ? {} : { project: root };
@@ -1789,7 +2869,11 @@ const overviewStream = (context, res, url, shutdown) => {
 			limit: OVERVIEW_RUNS
 		}).map((run) => viewOf$2(context, run));
 		const decisions = pendingDecisions(context.store, filter);
-		for (const [name, value] of [["runs", runs], ["decisions", decisions]]) {
+		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;
@@ -1805,10 +2889,53 @@ const overviewStream = (context, res, url, shutdown) => {
 	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);
+	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");
@@ -1844,6 +2971,10 @@ const createDispatch = (context, access) => {
 			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);
@@ -1911,6 +3042,11 @@ 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,
@@ -1918,9 +3054,12 @@ const startServer = async (options) => {
 		startedAt,
 		...options.home === void 0 ? {} : { home: options.home },
 		...options.script === void 0 ? {} : { script: options.script },
-		...uiDir === void 0 ? {} : { uiDir }
+		...uiDir === void 0 ? {} : { uiDir },
+		...options.gh === void 0 ? {} : { gh: options.gh },
+		updates,
+		...options.restart === void 0 ? {} : { restart: options.restart }
 	};
-	const token = newToken();
+	const token = options.token ?? newToken();
 	const shutdown = new AbortController();
 	const log = options.log ?? ((line) => {
 		process.stderr.write(`${line}\n`);
@@ -1941,6 +3080,7 @@ const startServer = async (options) => {
 	try {
 		port = await listen(server, port);
 	} catch (error) {
+		updates.close();
 		store.close();
 		throw error;
 	}
@@ -1956,9 +3096,14 @@ const startServer = async (options) => {
 		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);
@@ -1970,4 +3115,4 @@ const startServer = async (options) => {
 		}
 	};
 };
-export { openMcp as a, refused as c, uiFilePath as i, startServer as n, tool as o, runningServer as r, answer as s, DEFAULT_PORT as t };
+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 };