@krapht/ork 0.3.0 → 0.4.0

package/dist/bin.mjs

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
-import { $ as replayLoopAnswers, $t as projectsHome, Bt as linkTools, Cn as beforeOf, Ct as FEEDBACK_SEVERITIES, Dt as targetOf, E as planNodeSession, Et as fingerprint, Ft as socketPath, Gt as catalogAgent, H as requestStop, Ht as toolsInUse, I as peerOf, It as wakeRun, Jt as hasInRepoFiles, Kt as loadAgents, L as tellNode, Lt as planAgentMigration, M as addressOf, Mn as ORK_LAYOUT, N as endLink, Nn as CLAUDE_DRIVERS, O as parseInputPairs, On as INTEGRATIONS, Ot as maskReplacer, P as endLinksOf, Pn as firstLine, Pt as serveRun, Q as createReplay, Qt as placeFor, Rt as applySteps, St as FEEDBACK_KINDS, Tt as createFeedback, U as tellLiveRun, Ut as createAgent, Vt as toolLinks, Wt as deleteAgent, X as detachResume, Xt as newProjectId, Y as adoptedCalls, Yt as inRepoPlace, Z as resumable, Zt as placeFiles, b as inspectProject, d as triggersReport, dt as startRun, en as runDirOf, hn as serializeWorkflow, i as NOT_STARTED, in as projectRootOf, j as createCalls, jn as AGENT_TOOL_LAYOUTS, k as resolveInputs, kt as maskSecrets, l as detectInstaller, n as resolveBase, nt as followEvents, ot as runStatus, pt as userMessageText, rn as inside, rt as liveStatus, st as runTree, t as createWorkspace, tn as shownPath, tt as detachRun, u as lateTriggers, ut as walkSummary, wn as isClaudeNode, xn as settingsOf, xt as gitRulesOf, yn as WorkflowSchema, z as flattenTree, zt as planMoveInto } from "./src-Cz1yOUTg.mjs";
-import { a as pendingDecisions, i as answerDecision, n as ORK_VERSION, r as nodeSession, t as ORK_NAME } from "./__build_info__-CXXMLvjt.mjs";
-import { n as newRunId, t as findRun } from "./find-BcvhT6UN.mjs";
-import { a as write, c as openStore, i as style, l as storePath, n as cost, o as writeErr, s as nodeOf, t as confirm } from "./output-Q2EdeVUt.mjs";
-import { a as formatRunEvent, c as createdWorktrees, i as formatEvent, l as listOrkWorktrees, n as formatRuns, o as createTerminalHuman, r as formatTree, s as applyClean, t as ago, u as planClean } from "./format-DqpObyMl.mjs";
-import { a as validate, c as warningLines, d as workflowArg, f as projectAt, i as loadWorkflow, l as WORKFLOW_DIR, o as validateFile, p as isNewer, r as formatReport, s as walkLoaded, t as context, u as WORKFLOW_SUFFIX } from "./context-BFGC_C02.mjs";
-import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-BKYAmqCR.mjs";
-import { _ as resultOf, a as builtinExecutors, d as maskedEnv, f as maskedNamesOfRun, g as clearOutputFiles, h as sessionEnv, i as onPath, l as clearStateFiles, m as runScrubber, n as missingProgramMessage, r as missingPrograms, t as envProblems } from "./src-DtN1k-B3.mjs";
-import { i as decideRefusal, n as chatRefusal } from "./in-a-run-BbLhZOFW.mjs";
+import { $ as resumable, $t as planMoveInto, A as parseInputPairs, At as FEEDBACK_KINDS, Bn as isClaudeNode, Bt as normalizeTitle, F as endLink, Fn as WorkflowSchema, G as tellLiveRun, Ht as maskReplacer, I as endLinksOf, It as sendPost, Jn as ORK_LAYOUT, Jt as serveRun, Ln as settingsOf, Mt as FEEDBACK_TARGETS, N as createCalls, P as addressOf, Pt as planPost, Q as detachResume, Qt as applySteps, R as peerOf, Rt as createFeedback, T as inspectProject, V as flattenTree, W as requestStop, Wn as INTEGRATIONS, Xn as firstLine, Xt as wakeRun, Yn as CLAUDE_DRIVERS, Yt as socketPath, Z as adoptedCalls, Zt as planAgentMigration, _n as inside, an as catalogAgent, cn as hasInRepoFiles, d as runningRunIds, dn as placeFiles, dt as runStatus, en as linkTools, et as createReplay, f as runningScript, fn as placeFor, ft as runTree, g as triggersReport, h as lateTriggers, hn as shownPath, i as NOT_STARTED, in as deleteAgent, it as followEvents, j as resolveInputs, jn as serializeWorkflow, jt as FEEDBACK_SEVERITIES, kt as gitRulesOf, l as planUpgrade, ln as inRepoPlace, lt as liveStatus, m as isNewer, mn as runDirOf, n as resolveBase, nn as toolsInUse, on as loadAgents, pn as projectsHome, qn as AGENT_TOOL_LAYOUTS, rn as createAgent, rt as detachRun, st as planNodeSession, t as createWorkspace, tn as toolLinks, tt as replayLoopAnswers, u as releaseNotes, un as newProjectId, vn as projectRootOf, vt as walkSummary, xt as userMessageText, yt as startRun, z as tellNode, zn as beforeOf, zt as fingerprint } from "./src-CGqMati3.mjs";
+import { C as checkNote, D as placeOf, O as feedbackActions, S as previewPost, T as acceptItem, _ as answerDecision, b as builtinWorkflowFile, c as checkDue, d as pendingNotice, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, k as openFixRun, l as fetchLatest, m as updateCachePath, n as ORK_VERSION, o as updateSwitchOff, p as refreshUpdateCache, r as isSwitchedOn, s as runInstall, t as ORK_NAME, 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 { a as write, c as openStore, i as style, l as storePath, n as cost, o as writeErr, s as nodeOf, t as confirm } from "./output-CXSJO00X.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-ZvY2OcLq.mjs";
+import { a as planClean, t as applyClean } from "./clean-Dcr807be.mjs";
+import { a as formatRunEvent, i as formatEvent, n as formatRuns, o as createTerminalHuman, r as formatTree, t as ago } from "./format-J-a21Yvn.mjs";
+import { a as validate, c as warningLines, d as refusedBuiltin, f as workflowArg, i as loadWorkflow, l as WORKFLOW_DIR, m as registeredProjects, o as validateFile, p as projectAt, r as formatReport, s as walkLoaded, t as context, u as WORKFLOW_SUFFIX } from "./context-C_bksb0C.mjs";
+import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-BDZCmGEu.mjs";
+import { _ as resultOf, a as builtinExecutors, d as maskedEnv, f as maskedNamesOfRun, g as clearOutputFiles, h as sessionEnv, i as onPath, l as clearStateFiles, m as runScrubber, n as missingProgramMessage, r as missingPrograms, t as envProblems } from "./src-UWkk1sl9.mjs";
+import { i as decideRefusal, n as chatRefusal } from "./in-a-run-D1Qc5Mit.mjs";
 import { defineCommand, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { stringify } from "yaml";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { z } from "zod";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { setTimeout } from "node:timers/promises";
 import { execFile, spawn } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
 import { styleText } from "node:util";
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
@@ -208,41 +211,6 @@ const startControl = async (options) => {
 		}
 	};
 };
-// ../core/src/feedback/human.ts
-const RATINGS = ["good", "bad"];
-const MAX_TITLE = 120;
-/** The run event a note becomes; its title is the note's first line. */
-const humanNoteEvent = (note) => {
-	const text = maskSecrets(note.text.trim());
-	const [first = ""] = text.split("\n");
-	const title = first.slice(0, MAX_TITLE);
-	const kind = note.kind ?? "friction";
-	const target = targetOf({
-		kind,
-		title,
-		...note.target === void 0 ? {} : { target: note.target }
-	});
-	const feedback = {
-		source: "human",
-		kind,
-		target,
-		severity: note.severity ?? (note.rating === "bad" ? "high" : "medium"),
-		title,
-		body: text,
-		evidence: note.rating === void 0 ? [] : [`rating: ${note.rating}`],
-		fingerprint: fingerprint({
-			target,
-			kind,
-			title
-		}),
-		origin: { workflow: note.workflow }
-	};
-	return {
-		type: "feedback.recorded",
-		...note.node === void 0 ? {} : { node: note.node },
-		feedback
-	};
-};
 // ../core/src/feedback/signals.ts
 const ORK_TOOL = "mcp__ork__";
 /**
@@ -402,6 +370,47 @@ const createSignals = (options = {}) => {
 		return signal === null ? [event] : [event, ...record(...signal)];
 	};
 };
+/** A title's words, as fingerprints compare them. */
+const titleWords = (title) => new Set(normalizeTitle(title).split(" ").filter((word) => word !== ""));
+/** The share of two titles' words they have in common (Jaccard). */
+const titleOverlap = (a, b) => {
+	const left = titleWords(a);
+	const right = titleWords(b);
+	const union = /* @__PURE__ */ new Set([...left, ...right]);
+	if (union.size === 0) return 0;
+	return [...left].filter((word) => right.has(word)).length / union.size;
+};
+const unsettled = (item) => item.status === "new" || item.status === "triaged";
+const firstSeen = (a, b) => a.firstSeen.localeCompare(b.firstSeen) || a.id.localeCompare(b.id);
+/**
+* One kind of item's groups, oldest first: an item joins the first group whose
+* first-seen item it is near enough, so every member is within the rule of the
+* item the others go under, never only of one another.
+*/
+const groupsOf = (items) => {
+	const groups = [];
+	for (const item of items.toSorted(firstSeen)) {
+		const group = groups.find(([root]) => root !== void 0 && titleOverlap(root.title, item.title) >= .8);
+		if (group === void 0) groups.push([item]);
+		else group.push(item);
+	}
+	return groups;
+};
+/** The merges triage would make among `items`, oldest group first. */
+const proposeMerges = (items) => {
+	const byKind = /* @__PURE__ */ new Map();
+	for (const item of items.filter((i) => unsettled(i))) {
+		const key = `${item.target}/${item.kind}`;
+		byKind.set(key, [...byKind.get(key) ?? [], item]);
+	}
+	return [...byKind.values()].flatMap((sameKind) => groupsOf(sameKind)).filter((group) => group.length > 1 && group.some((item) => item.status === "new")).map((group) => {
+		const [into, ...from] = group;
+		return into === void 0 ? void 0 : {
+			into,
+			from
+		};
+	}).filter((merge) => merge !== void 0).toSorted((a, b) => firstSeen(a.into, b.into));
+};
 // ../core/src/remote/relay.ts
 /**
 * @file A run's side of the relay (RFC-003): its nodes' links, read from the
@@ -526,97 +535,6 @@ const createRecorder = (store, run, runDir) => {
 	store.begin(run);
 	return appendRecorder(store, run.id, runDir);
 };
-const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const text = (record, key) => {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-};
-const notifiedOf = (value) => {
-	if (!isRecord(value)) return void 0;
-	const version = text(value, "version");
-	const at = text(value, "at");
-	return version === void 0 || at === void 0 ? void 0 : {
-		version,
-		at
-	};
-};
-/** The cache, or `null` when there is none or it cannot be read. */
-const readUpdateCache = (file) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return null;
-	}
-	if (!isRecord(parsed)) return null;
-	const checkedAt = text(parsed, "checkedAt");
-	if (checkedAt === void 0) return null;
-	const latest = text(parsed, "latest");
-	const notified = notifiedOf(parsed["notified"]);
-	return {
-		checkedAt,
-		...latest === void 0 ? {} : { latest },
-		...notified === void 0 ? {} : { notified }
-	};
-};
-/** Writes the cache whole (a temporary file, then a rename). */
-const writeUpdateCache = (file, cache) => {
-	mkdirSync(path.dirname(file), { recursive: true });
-	const temporary = `${file}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
-	renameSync(temporary, file);
-};
-const age = (iso, now) => {
-	const time = Date.parse(iso);
-	return Number.isNaN(time) ? Infinity : now.getTime() - time;
-};
-/** Whether it is time to ask the registry again. */
-const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
-/** The package's `latest` version on the registry, or `null` on any failure. */
-const fetchLatest = async (name, options = {}) => {
-	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
-	const get = options.fetch ?? globalThis.fetch;
-	try {
-		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
-			headers: { accept: "application/json" },
-			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
-		});
-		if (!response.ok) return null;
-		const tags = await response.json();
-		return (isRecord(tags) ? text(tags, "latest") : void 0) ?? null;
-	} catch {
-		return null;
-	}
-};
-/**
-* Asks the registry and records the answer. A failed check is recorded too, so
-* an offline machine is not asked again until the interval passes; the last
-* known `latest` is kept.
-*/
-const refreshUpdateCache = async (file, name, now, options = {}) => {
-	const before = readUpdateCache(file);
-	const latest = await fetchLatest(name, options) ?? before?.latest;
-	const cache = {
-		...before,
-		checkedAt: now.toISOString(),
-		...latest === void 0 ? {} : { latest }
-	};
-	writeUpdateCache(file, cache);
-	return cache;
-};
-/** The newer version the cache knows of, if any. */
-const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
-/**
-* The version to tell the user about now: newer than theirs, and not already
-* told today. `null` when there is nothing to say.
-*/
-const pendingNotice = (cache, current, now) => {
-	const newer = newerVersion(cache, current);
-	if (newer === null) return null;
-	const told = cache?.notified;
-	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
-};
 // src/runs/chat.ts
 /**
 * @file `ork chat`'s two paths. A node of a live run gets the message through
@@ -1273,7 +1191,7 @@ const flagValues = (rawArgs, flag) => {
 };
 const isDriver = (value) => CLAUDE_DRIVERS.some((d) => d.id === value);
 /** Loads the drivers only when a run starts, so other commands stay fast. */
-const loadRuntime = async (driver) => (await import("./src-CZOVF2yU.mjs")).createRuntime(driver, sessionEnv(process.env));
+const loadRuntime = async (driver) => (await import("./src-BHnxpJyH.mjs")).createRuntime(driver, sessionEnv(process.env));
 /**
 * Ctrl-C asks the run to stop, and so does a terminal closing or a polite kill,
 * so that the run ends tidily and leaves no result unscrubbed.
@@ -1304,7 +1222,7 @@ const run = defineCommand({
 	args: {
 		workflow: {
 			type: "positional",
-			description: "A workflow file, or the name of one in the project's workflows (.ork/workflows/)",
+			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
 			required: true
 		},
 		node: {
@@ -1375,6 +1293,7 @@ const run = defineCommand({
 			return;
 		}
 		const cwd = process.cwd();
+		if (refusedBuiltin([args.workflow], cwd)) return;
 		const target = workflowArg(args.workflow, cwd);
 		const store = openStore();
 		if (args.detach) {
@@ -1591,18 +1510,44 @@ const chat = defineCommand({
 		}
 	}
 });
-// src/commands/control.ts
+// src/commands/decide.ts
 /**
-* @file `ork decide`, `ork stop` and `ork resume`: answer a live run's open
-*   decisions and stop a live run, or one of its nodes (ADR-041), from any
-*   terminal (both write to the store, then wake the run on its socket;
-*   specs/messaging.md), and continue a stopped or crashed run with its
-*   recorded state (ADR-026).
+* @file `ork decide`: answer a live run's open decisions from any terminal (it
+*   writes to the store, then wakes the run on its socket; specs/messaging.md).
+*   With `--id` and `--choose`, `--note` and `--rating` also note how the
+*   decision's node went, as the run's feedback (specs/feedback.md).
 */
-const failed = (message) => {
+const failed$2 = (message) => {
 	writeErr(message);
 	process.exitCode = 1;
 };
+/**
+* Notes the answered decision's node, when there's a note or a rating; a rating
+* alone is its note's words.
+*/
+const noteDecision = (store, id, note, rating) => {
+	if (note === void 0 && rating === void 0) return void 0;
+	const decision = store.decision(id);
+	const [run] = decision === void 0 ? [] : store.lookup(decision.runId);
+	if (decision === void 0 || run === void 0) return {
+		ok: false,
+		error: `No decision ${id} to note.`
+	};
+	return recordNote(store, run, {
+		text: note ?? `Rated ${rating ?? ""} at ${decision.question}`,
+		node: decision.node,
+		rating
+	}, "--");
+};
+/** Why a note given with an answer can't be recorded, before answering. */
+const noteProblem = (note, rating) => {
+	if (note === void 0 && rating === void 0) return void 0;
+	const checked = checkNote({
+		text: note ?? "rated",
+		rating
+	}, "--");
+	return checked.ok ? void 0 : checked.error;
+};
 /** One line per open decision, for `--list`. */
 const formatDecisions = (decisions) => decisions.length === 0 ? ["No open decisions."] : decisions.map((d) => `${style("bold", d.id)}  ${style("cyan", d.node)}  ${d.question} ${style("dim", `[${d.options.map((o) => o.id === d.recommended ? `${o.id}*` : o.id).join(", ")}]`)}`);
 const decide = defineCommand({
@@ -1638,12 +1583,20 @@ const decide = defineCommand({
 		choose: {
 			type: "string",
 			description: "…with this option"
+		},
+		note: {
+			type: "string",
+			description: "…and note how its node went; the note joins the run's feedback"
+		},
+		rating: {
+			type: "string",
+			description: "…rating it good or bad"
 		}
 	},
 	run: async ({ args }) => {
 		const refusal = args.id !== void 0 || args.choose !== void 0 || process.stdin.isTTY && !args.list && !args.json ? decideRefusal() : null;
 		if (refusal !== null) {
-			failed(refusal);
+			failed$2(refusal);
 			return;
 		}
 		const store = openStore();
@@ -1655,19 +1608,35 @@ const decide = defineCommand({
 		try {
 			if (args.id !== void 0 || args.choose !== void 0) {
 				if (args.id === void 0 || args.choose === void 0) {
-					failed("--id and --choose go together.");
+					failed$2("--id and --choose go together.");
+					return;
+				}
+				const problem = noteProblem(args.note, args.rating);
+				if (problem !== void 0) {
+					failed$2(problem);
 					return;
 				}
 				const answered = await answerDecision(store, args.id, args.choose);
-				if (answered.ok) write(`${style("green", "✓")} ${args.id}: ${args.choose}`);
-				else failed(answered.error);
+				if (!answered.ok) {
+					failed$2(answered.error);
+					return;
+				}
+				write(`${style("green", "✓")} ${args.id}: ${args.choose}`);
+				const noted = noteDecision(store, args.id, args.note, args.rating);
+				if (noted === void 0) return;
+				if (noted.ok) write(`${style("green", "✓")} noted in item ${noted.item}`);
+				else failed$2(noted.error);
+				return;
+			}
+			if (args.note !== void 0 || args.rating !== void 0) {
+				failed$2("--note and --rating go with --id and --choose.");
 				return;
 			}
 			const filter = {};
 			if (args.run !== void 0 && args.run !== "") {
 				const found = findRun(store, args.run, process.cwd());
 				if (!found.ok) {
-					failed(found.error);
+					failed$2(found.error);
 					return;
 				}
 				filter.runId = found.run.id;
@@ -1700,6 +1669,17 @@ const decide = defineCommand({
 		}
 	}
 });
+// src/commands/control.ts
+/**
+* @file `ork stop` and `ork resume`: stop a live run, or one of its nodes
+*   (ADR-041), from any terminal (it writes to the store, then wakes the run on
+*   its socket; specs/messaging.md), and continue a stopped or crashed run with
+*   its recorded state (ADR-026). `ork decide` is in `decide.ts`.
+*/
+const failed$1 = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
 const stop = defineCommand({
 	meta: {
 		name: "stop",
@@ -1721,13 +1701,13 @@ const stop = defineCommand({
 		try {
 			const found = findRun(store, args.run, process.cwd());
 			if (!found.ok) {
-				failed(found.error);
+				failed$1(found.error);
 				return;
 			}
 			const { run } = found;
 			const asked = await requestStop(store, run, void 0, args.node);
 			if (!asked.ok) {
-				failed(asked.error);
+				failed$1(asked.error);
 				return;
 			}
 			if (args.node !== void 0) {
@@ -1790,7 +1770,7 @@ const resume = defineCommand({
 	},
 	run: async ({ args, rawArgs }) => {
 		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			failed(`--driver must be sdk or cli, got \`${args.driver}\``);
+			failed$1(`--driver must be sdk or cli, got \`${args.driver}\``);
 			return;
 		}
 		const store = openStore();
@@ -1802,14 +1782,14 @@ const resume = defineCommand({
 				...args.driver === void 0 ? {} : { driver: args.driver }
 			}) : found;
 			if (!found.ok || !ready.ok) {
-				failed(ready.ok ? "" : ready.error);
+				failed$1(ready.ok ? "" : ready.error);
 				return;
 			}
 			if (args.detach) {
 				const flags = rawArgs.filter((a) => a !== "--detach" && a !== args.run);
 				const detached = await detachResume(store, found.run, flags);
 				if (detached.ok) write(`▸ run ${found.run.id} resumed in the background`);
-				else failed(`${detached.error}\n(output: ${detached.log})`);
+				else failed$1(`${detached.error}\n(output: ${detached.log})`);
 				return;
 			}
 			const { exitCode } = await runWorkflowFile({
@@ -1852,22 +1832,20 @@ const resume = defineCommand({
 */
 /** Set in the background copy of `ork` that only runs the check. */
 const UPDATE_CHILD_ENV = "ORK_UPDATE_CHECK_CHILD";
-/** A registry to ask instead of npm's, e.g. a company mirror. */
-const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
-const on = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
-/** Why the automatic check is off for this command, or `null` when it is on. */
+/**
+* Why the automatic check is off for this command, or `null` when it is on: the
+* environment's switches (core's, which `ork ui` reads too), then where a
+* notice on stderr would go.
+*/
 const updateCheckOff = (env, argv, terminal) => {
-	if (on(env["ORK_NO_UPDATE_CHECK"]) || on(env["NO_UPDATE_NOTIFIER"])) return "turned off";
-	if (on(env["CI"])) return "in CI";
-	if (on(env["ORK_DETACHED"]) || !terminal) return "no terminal";
+	const switched = updateSwitchOff(env);
+	if (switched !== null) return switched === "CI" ? "in CI" : "turned off";
+	if (isSwitchedOn(env["ORK_DETACHED"]) || !terminal) return "no terminal";
 	if (argv.includes("--json")) return "JSON output";
 	if (argv[0] === "upgrade") return "ork upgrade checks for itself";
+	if (argv[0] === "ui" && argv.includes("--serve")) return "ork ui's server checks for itself";
 	return null;
 };
-const registryOf = (env) => {
-	const registry = env[UPDATE_REGISTRY_ENV];
-	return registry === void 0 || registry === "" ? void 0 : registry;
-};
 /** The notice's text. */
 const updateNotice = (latest, current) => `Ork ${latest} is out (you have ${current}). Upgrade with: ork upgrade`;
 /**
@@ -1918,54 +1896,11 @@ const showUpdateNotice = (file = updateCachePath(), now = /* @__PURE__ */ new Da
 };
 // src/update/upgrade.ts
 /**
-* @file What `ork upgrade` does (ADR-038): compares the registry's latest
-*   version with this one, works out how Ork was installed, and gives the
-*   command to run (a global npm, pnpm, yarn, bun or Volta install) or advice
-*   (a clone, `npx`); runs the command when the user agrees. Also the version
-*   line of `ork doctor`, read from the cache without asking the network.
-*/
-const REPOSITORY = "https://github.com/mimshins/ork";
-/** The GitHub release page of a version, with its changes. */
-const releaseNotes = (name, version) => `${REPOSITORY}/releases/tag/${encodeURIComponent(`${name}@${version}`)}`;
-/** The running script's real path, which tells how Ork was installed. */
-const runningScript = () => {
-	const script = process.argv[1] ?? "";
-	try {
-		return realpathSync(script);
-	} catch {
-		return script;
-	}
-};
-const planUpgrade = (options) => {
-	const { latest, name } = options;
-	if (latest === null) return { kind: "unreachable" };
-	if (!isNewer(latest, options.current)) return { kind: "latest" };
-	const spec = `${name}@${latest}`;
-	const installer = detectInstaller(options.script, options.installers);
-	if (installer?.command !== void 0) return {
-		kind: "command",
-		latest,
-		installer,
-		argv: installer.command(spec)
-	};
-	return {
-		kind: "advice",
-		latest,
-		text: installer?.advice?.(spec, options.script.replaceAll("\\", "/")) ?? `Ork could not tell how it was installed. With npm: npm install --global ${spec}`
-	};
-};
-/** Runs the installer's command on this terminal; resolves its exit code. */
-const runInstall = (argv) => new Promise((resolve) => {
-	const [program = "", ...args] = argv;
-	const child = spawn(program, args, { stdio: "inherit" });
-	child.on("error", (error) => {
-		process.stderr.write(`Could not run ${program}: ${error.message}\n`);
-		resolve(127);
-	});
-	child.on("close", (code) => {
-		resolve(code ?? 1);
-	});
-});
+* @file `ork doctor`'s line for Ork itself (ADR-038): the running version
+*   against the last update check, read from the record without asking the
+*   network. What `ork upgrade` does is core's (`planUpgrade`, `runInstall`),
+*   shared with the server behind `ork ui`.
+*/
 /** `ork doctor`'s line for Ork itself, from the last check. */
 const versionCheck = (current, cache, checksOff) => {
 	const newer = newerVersion(cache, current);
@@ -2301,7 +2236,7 @@ const doctor = defineCommand({
 const runningRuns = () => {
 	const store = openStore();
 	try {
-		return store.runs({ limit: 500 }).filter((run) => liveStatus(run) === "running").map((run) => run.id.slice(0, 8));
+		return runningRunIds(store).map((id) => id.slice(0, 8));
 	} finally {
 		store.close();
 	}
@@ -2914,33 +2849,6 @@ const migrateHere = async (cwd, options) => {
 		store.close();
 	}
 };
-// src/project/worktrees.ts
-/** One line of state: where it is and what clean would care about. */
-const worktreeState = (item) => {
-	const parts = [];
-	if (item.path === null) parts.push("no worktree");
-	else if (item.missing) parts.push("missing (prunable)");
-	if (item.dirty) parts.push(style("yellow", "uncommitted changes"));
-	const commits = item.merged ? style("green", "merged") : `${String(item.ahead)} commit(s) not merged`;
-	if (item.checkedOut !== void 0) parts.push(`on the workflow's branch ${item.checkedOut}`, commits);
-	else if (item.branch === void 0) parts.push(item.ahead > 0 ? style("yellow", `detached, ${String(item.ahead)} commit(s) on no branch`) : "detached, nothing committed");
-	else parts.push(commits);
-	if (item.inMainCheckout) parts.push("checked out here");
-	return parts.join(" · ");
-};
-/** A worktree's name: its branch, or its run and node when created detached. */
-const labelOf = (item) => item.branch ?? `${item.runId}/${item.nodeId} (detached)`;
-const formatWorktrees = (items) => {
-	if (items.length === 0) return ["No Ork worktrees or branches."];
-	const width = Math.max(...items.map((i) => labelOf(i).length));
-	return items.flatMap((item) => [`${style("bold", labelOf(item).padEnd(width))}  ${worktreeState(item)}`, ...item.path === null ? [] : [`  ${style("dim", item.path)}`]]);
-};
-const formatPlan = (steps) => steps.map((step) => {
-	const actions = [...step.removeWorktree ? ["remove worktree"] : [], ...step.deleteBranch ? ["delete branch"] : []];
-	const what = actions.length > 0 ? actions.join(" + ") : "keep";
-	const why = step.skip === void 0 ? "" : style("dim", ` (${step.skip})`);
-	return `  ${labelOf(step.item)}: ${what}${why}`;
-});
 // src/commands/project-records.ts
 /**
 * @file `ork projects`' subcommands on one project's record (ADR-035): `forget`
@@ -3006,124 +2914,8 @@ const move = defineCommand({
 *   follows its moved clone (ADR-035); none writes into a repository. `ork
 *   migrate` moves an attached project into its repository, brings its agents
 *   and skills under `.ork/`, or drafts a workflow from its agents (ADR-036),
-*   and commits nothing. `ork worktrees` lists the worktrees and branches runs
-*   left behind (those the runs recorded creating, whatever the project's git
-*   rules named them, and any `ork/` branch), with their state read from git,
-*   and cleans them up safely after showing the plan and asking.
-*/
-const projectRoot = async () => (await inspectProject(process.cwd()))?.root ?? null;
-/** What Ork created in the repo at `root`, from its runs' records and git. */
-const itemsIn = async (root) => {
-	const store = openStore();
-	try {
-		return await listOrkWorktrees(root, createdWorktrees(store, root));
-	} finally {
-		store.close();
-	}
-};
-const notGit = () => {
-	process.stderr.write("Not in a git repository with a commit.\n");
-	process.exitCode = 1;
-};
-const show = async (json) => {
-	const root = await projectRoot();
-	if (root === null) {
-		notGit();
-		return;
-	}
-	const items = await itemsIn(root);
-	if (json) write(JSON.stringify(items, void 0, 2));
-	else for (const line of formatWorktrees(items)) write(line);
-};
-const list = defineCommand({
-	meta: {
-		name: "list",
-		description: "List Ork's worktrees and branches (the default)"
-	},
-	args: { json: {
-		type: "boolean",
-		description: "Print JSON",
-		default: false
-	} },
-	run: ({ args }) => show(args.json)
-});
-const clean = defineCommand({
-	meta: {
-		name: "clean",
-		description: "Remove Ork's worktrees (merged ones by default); never one with uncommitted changes unless --force"
-	},
-	args: {
-		run: {
-			type: "string",
-			description: "Only this run's worktrees"
-		},
-		all: {
-			type: "boolean",
-			description: "Include worktrees whose branch is not merged",
-			default: false
-		},
-		branches: {
-			type: "boolean",
-			description: "Also delete the branches",
-			default: false
-		},
-		force: {
-			type: "boolean",
-			description: "Remove uncommitted changes and unmerged branches too",
-			default: false
-		},
-		yes: {
-			type: "boolean",
-			description: "Do not ask",
-			default: false
-		}
-	},
-	run: async ({ args }) => {
-		const root = await projectRoot();
-		if (root === null) {
-			notGit();
-			return;
-		}
-		const filter = { merged: !args.all };
-		if (args.run !== void 0) filter.runId = args.run;
-		const steps = planClean(await itemsIn(root), filter, {
-			branches: args.branches,
-			force: args.force
-		});
-		const acting = steps.filter((s) => s.removeWorktree || s.deleteBranch);
-		if (steps.length === 0 || acting.length === 0) {
-			for (const line of formatPlan(steps)) write(line);
-			write("Nothing to clean.");
-			return;
-		}
-		write("Plan:");
-		for (const line of formatPlan(steps)) write(line);
-		if (!args.yes) {
-			if (!process.stdin.isTTY) {
-				process.stderr.write("Pass --yes to clean without a terminal.\n");
-				process.exitCode = 1;
-				return;
-			}
-			if (!await confirm("Go ahead? [y/N] ")) return;
-		}
-		for (const line of await applyClean(root, acting, args.force)) write(`${style("green", "✓")} ${line}`);
-	}
-});
-const worktrees = defineCommand({
-	meta: {
-		name: "worktrees",
-		description: "Track and clean up the git worktrees Ork creates for runs"
-	},
-	subCommands: {
-		list,
-		clean
-	},
-	run: async ({ rawArgs }) => {
-		const [first] = rawArgs;
-		if (first === "list" || first === "clean") return;
-		await show(rawArgs.includes("--json"));
-	}
-});
+*   and commits nothing. `ork worktrees` is worktrees.ts.
+*/
 const json$2 = {
 	type: "boolean",
 	description: "Print JSON",
@@ -3220,6 +3012,20 @@ const migrate = defineCommand({
 		}, (file) => formatReport(validateFile(file, process.cwd())));
 	}
 });
+// src/store.ts
+/**
+* @file Opening the user's store (`~/.ork/state.db`) for the length of one
+*   command, and closing it after, whatever happens.
+*/
+/** Runs `body` with the user's store open, and closes it after. */
+const withStore = async (body) => {
+	const store = openStore();
+	try {
+		await body(store);
+	} finally {
+		store.close();
+	}
+};
 // src/runs/feedback.ts
 /**
 * @file `ork feedback`'s helpers (specs/feedback.md): finding an item by a
@@ -3269,6 +3075,7 @@ const formatFeedbackItem = (item, records, now = Date.now()) => {
 	];
 	if (item.workflows.length > 0) lines.push(`Workflows: ${item.workflows.join(", ")}`);
 	if (item.models.length > 0) lines.push(`Models: ${item.models.join(", ")}`);
+	if (item.merged.length > 0) lines.push(`Merged into it: ${item.merged.map((id) => id.slice(0, 12)).join(", ")} (ork feedback split ${item.id.slice(0, 12)} takes them apart)`);
 	for (const record of records) {
 		const { feedback } = record;
 		const where = record.node === void 0 ? "" : ` · ${record.node}`;
@@ -3279,181 +3086,533 @@ const formatFeedbackItem = (item, records, now = Date.now()) => {
 	}
 	return lines;
 };
-const oneOf = (name, value, allowed) => {
-	if (value === void 0) return { ok: true };
-	const found = allowed.find((a) => a === value);
-	return found === void 0 ? {
-		ok: false,
-		error: `--${name} is one of ${allowed.join(", ")}`
-	} : {
-		ok: true,
-		value: found
-	};
-};
 /**
 * `ork feedback note`: records a person's note on a run, or one of its nodes,
 * as that run's feedback; returns the item it joins, or why it could not.
 */
 const noteRun = (store, cwd, args) => {
-	if (args.text.trim() === "") return {
+	const found = findRun(store, args.run, cwd);
+	if (!found.ok) return found;
+	return recordNote(store, found.run, args, "--");
+};
+// src/runs/apply.ts
+/**
+* @file `ork feedback apply` (ADR-059): runs Ork's own `ork:feedback-apply` in
+*   the project an item came from, with the item as its untrusted input. Its
+*   worker proposes a fix on a branch and its gate asks to keep or discard it;
+*   Ork never merges. Kept, the item is `resolved`; discarded, the run's
+*   worktree and branch go and the item stays `accepted`.
+*/
+/** The most of an item's records the worker reads, newest first. */
+const RECORDS = 10;
+/** The most of a record's body the worker reads. */
+const BODY_CHARS = 1500;
+const BUILTIN = "ork:feedback-apply";
+/** An item and its newest records, as the worker reads them. */
+const aboutItem = (item, records) => {
+	const newest = records.toReversed().slice(0, RECORDS);
+	const lines = [`Item ${item.id.slice(0, 12)}: ${item.title}`, `About: ${item.target} (${item.kind}), severity ${item.severity}; seen ${String(item.count)} time(s) in ${String(item.runs.length)} run(s).`];
+	if (item.workflows.length > 0) lines.push(`Workflows: ${item.workflows.join(", ")}`);
+	for (const record of newest) {
+		const { feedback } = record;
+		const where = record.node === void 0 ? "" : `, node ${record.node}`;
+		lines.push("", `Record from run ${record.runId}${where} (${feedback.source}):`);
+		if (feedback.title !== item.title) lines.push(feedback.title);
+		if (feedback.body !== "") lines.push(feedback.body.slice(0, BODY_CHARS));
+		if (feedback.evidence.length > 0) lines.push(`Evidence: ${feedback.evidence.join(", ")}`);
+	}
+	if (records.length > newest.length) lines.push("", `(${String(records.length - newest.length)} older record(s) left out.)`);
+	return lines.join("\n");
+};
+const text = (value) => typeof value === "string" ? value : "";
+/** What a run of `ork:feedback-apply` ended with. */
+const outcomeOf = (result) => {
+	const node = (id) => result?.nodes.find((n) => n.id === id);
+	const fix = node("fix");
+	const choice = text(node("keep")?.output?.["choice"]);
+	const branch = text(fix?.output?.["branch"]);
+	const summary = text(fix?.output?.["summary"]);
+	if (choice === "keep") return {
+		kind: "kept",
+		branch,
+		summary
+	};
+	if (choice === "discard") return {
+		kind: "discarded",
+		branch
+	};
+	if (fix?.ok === false && result?.status === "failed") return {
+		kind: "nothing",
+		summary: summary || (fix.error ?? "")
+	};
+	return {
+		kind: "unfinished",
+		reasons: result?.reasons ?? []
+	};
+};
+/**
+* Removes what a run left in the repository at `root`: its worktrees and
+* branches.
+*/
+const discardRun = async (store, root, runId) => {
+	const items = await listOrkWorktrees(root, createdWorktrees(store, root));
+	const steps = planClean(items, {
+		merged: false,
+		runId
+	}, {
+		branches: true,
+		force: true
+	});
+	return applyClean(root, steps.filter((s) => s.removeWorktree || s.deleteBranch), true);
+};
+/** How many commits the run's worktrees hold that the current branch hasn't. */
+const commitsAhead = async (store, root, runId) => (await listOrkWorktrees(root, createdWorktrees(store, root))).filter((item) => item.runId === runId).reduce((sum, item) => sum + item.ahead, 0);
+/** What to say, and the item's status, after the run ends as `outcome`. */
+const settle = async (options, root, runId, outcome) => {
+	const { store, item } = options;
+	const short = item.id.slice(0, 12);
+	switch (outcome.kind) {
+		case "kept":
+			if (await (options.ahead ?? commitsAhead)(store, root, runId) === 0) {
+				const done = await discardRun(store, root, runId);
+				return [`the fix's branch holds no commits, so there's nothing to keep; ${short} stays accepted`, ...done];
+			}
+			store.setFeedbackStatus(item.id, "resolved");
+			return [`kept the fix on ${outcome.branch}; ${short} is resolved`, "Review and merge it like any other change; Ork never merges it."];
+		case "discarded": {
+			const done = await discardRun(store, root, runId);
+			return [`discarded the fix; ${short} stays accepted`, ...done];
+		}
+		case "nothing": return [`no fix proposed; ${short} stays accepted`, ...outcome.summary === "" ? [] : [outcome.summary]];
+		case "unfinished": return [`run ${runId} didn't finish, so ${short} stays as it was`, ...outcome.reasons];
+		default: return outcome;
+	}
+};
+/** Proposes a fix for an item, in the project it came from. */
+const applyItem = async (options) => {
+	const { store, item } = options;
+	const short = item.id.slice(0, 12);
+	const allowed = feedbackActions(item, openFixRun(store, item)).apply;
+	if (!allowed.ok) return {
 		ok: false,
-		error: "The note is empty."
+		error: allowed.error
 	};
-	const found = findRun(store, args.run, cwd);
+	const found = placeOf(store, item, void 0, options.registered);
 	if (!found.ok) return found;
-	const { run } = found;
-	const ran = store.events(run.id).some(({ event }) => "id" in event && event.id === args.node);
-	if (args.node !== void 0 && !ran) return {
+	const { place, project } = found;
+	const problem = builtinProblem(place, BUILTIN);
+	const file = builtinWorkflowFile(place, BUILTIN);
+	if (problem !== void 0 || file === void 0) return {
 		ok: false,
-		error: `No node ${args.node} ran in run ${run.id}.`
-	};
-	const kind = oneOf("kind", args.kind, FEEDBACK_KINDS);
-	const severity = oneOf("severity", args.severity, FEEDBACK_SEVERITIES);
-	const rating = oneOf("rating", args.rating, RATINGS);
-	for (const checked of [
-		kind,
-		severity,
-		rating
-	]) if (!checked.ok) return checked;
-	const event = humanNoteEvent({
-		text: args.text,
-		workflow: run.workflow,
-		...args.node === void 0 ? {} : { node: args.node },
-		...kind.ok && kind.value !== void 0 ? { kind: kind.value } : {},
-		...severity.ok && severity.value !== void 0 ? { severity: severity.value } : {},
-		...rating.ok && rating.value !== void 0 ? { rating: rating.value } : {}
+		error: problem ?? `${BUILTIN} couldn't be written.`
+	};
+	const records = store.feedbackRecords(item.id).filter((r) => store.lookup(r.runId)[0]?.project === project);
+	options.out(`▸ proposing a fix for ${short} in ${place.root}`);
+	const { result } = await runWorkflowFile({
+		...options,
+		file,
+		cwd: place.root,
+		inputs: [`item=${short}`, `about=${aboutItem(item, records)}`],
+		untrusted: ["about"],
+		inPlace: false,
+		json: false,
+		onRun: (handle) => {
+			store.setFeedbackStatus(item.id, "accepted");
+			options.onRun?.(handle);
+		}
 	});
-	store.append(run.id, event);
+	if (result === null) return {
+		ok: false,
+		error: `${BUILTIN} didn't start.`
+	};
+	const outcome = outcomeOf(result);
 	return {
 		ok: true,
-		item: event.type === "feedback.recorded" ? event.feedback.fingerprint : ""
+		outcome,
+		lines: await settle(options, place.root, result.runId, outcome)
 	};
 };
-// src/commands/runs.ts
+// src/runs/triage.ts
 /**
-* @file `ork ps`, `ork logs`, `ork tree` and `ork feedback`: read what every
-*   project's runs recorded in `~/.ork/state.db` (specs/event-store.md,
-*   specs/feedback.md).
+* @file `ork feedback triage` (ADR-059): the merges Ork's rules propose among
+*   unsettled items, each made only when the person says yes, then every new
+*   item marked `triaged`, so a declined merge isn't asked again until a new
+*   item joins it. `ork feedback split` takes a merge apart.
 */
-/** Runs `body` with the user's store open, and closes it after. */
-const withStore = async (body) => {
-	const store = openStore();
-	try {
-		await body(store);
-	} finally {
-		store.close();
-	}
+const lineOf = (item) => `${item.id.slice(0, 12)} ${`${String(item.count)}×`.padStart(4)}  ${item.title}`;
+/** A proposed merge as the person reads it before saying yes. */
+const formatMerge = (merge) => [`Merge into ${lineOf(merge.into)}`, ...merge.from.map((item) => `      ${lineOf(item)}`)];
+/**
+* Proposes each merge, makes those `ask` says yes to, and marks every item that
+* was new `triaged`.
+*/
+const triage$1 = async (store, ask) => {
+	const items = store.feedbackItems();
+	const fresh = items.filter((item) => item.status === "new");
+	let merged = 0;
+	let declined = 0;
+	for (const merge of proposeMerges(items)) if (await ask(merge)) merged += store.mergeFeedback(merge.into.id, merge.from.map((item) => item.id));
+	else declined += 1;
+	for (const item of fresh) store.setFeedbackStatus(item.id, "triaged");
+	return {
+		merged,
+		declined,
+		triaged: fresh.length
+	};
 };
-const ps = defineCommand({
-	meta: {
-		name: "ps",
-		description: "List this project's runs, newest first"
-	},
-	args: {
-		all: {
-			type: "boolean",
-			description: "Every project's runs",
-			default: false
-		},
-		limit: {
-			type: "string",
-			description: "How many (default 20)"
-		},
-		json: {
-			type: "boolean",
-			description: "Print JSON",
-			default: false
-		}
-	},
-	run: ({ args }) => withStore((store) => {
-		const limit = Number(args.limit ?? 20);
-		const runs = store.runs({
-			limit: Number.isInteger(limit) && limit > 0 ? limit : 20,
-			...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root }
-		});
-		const statusOf = (run) => runStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
-		if (args.json) write(JSON.stringify(runs, void 0, 2));
-		else for (const line of formatRuns(runs, args.all, Date.now(), statusOf)) write(line);
-	})
-});
-const runArg = {
+/** What triage did, in a line. */
+const triageSummary = ({ merged, declined, triaged }) => {
+	return [
+		merged === 0 ? "nothing merged" : `merged ${String(merged)} item(s)`,
+		...declined === 0 ? [] : [`${String(declined)} merge(s) declined`],
+		`${String(triaged)} new item(s) triaged`
+	].join("; ");
+};
+// src/commands/feedback-loop.ts
+/**
+* @file The `ork feedback` subcommands that close the loop (ADR-059): `apply`
+*   runs Ork's own workflow to propose a fix for an item, `triage` merges items
+*   about the same problem by rules after asking, and `split` takes a merge
+*   apart.
+*/
+const itemArg$1 = {
 	type: "positional",
-	description: "A run id or a prefix of one (default: this project's newest)",
-	required: false
+	description: "A feedback item's id, or a prefix of one",
+	required: true
 };
-const logs = defineCommand({
+const apply = defineCommand({
 	meta: {
-		name: "logs",
-		description: "Print a run's transcript"
+		name: "apply",
+		description: "Have Ork propose a fix for an item on a branch, then keep or discard it"
 	},
 	args: {
-		run: runArg,
-		node: {
+		item: itemArg$1,
+		driver: {
 			type: "string",
-			description: "Only this node's events"
-		},
-		follow: {
-			type: "boolean",
-			alias: "f",
-			description: "Keep printing a live run's events until it ends",
-			default: false
+			description: "sdk (API key or cloud provider) or cli (your claude login)"
 		},
-		json: {
-			type: "boolean",
-			description: "Print the stored events as JSON lines",
-			default: false
+		"run-id": {
+			type: "string",
+			description: "Internal: the id `ork ui` picked for the run"
+		}
+	},
+	run: async ({ args }) => {
+		if (args.driver !== void 0 && !isDriver(args.driver)) {
+			writeErr(`--driver must be sdk or cli, got \`${args.driver}\``);
+			process.exitCode = 1;
+			return;
+		}
+		const driver = args.driver;
+		const store = openStore();
+		const human = terminalHuman();
+		try {
+			const found = findFeedbackItem(store, args.item);
+			if (!found.ok) {
+				writeErr(found.error);
+				process.exitCode = 1;
+				return;
+			}
+			const applied = await applyItem({
+				store,
+				item: found.item,
+				registered: registeredProjects(),
+				runtime: loadRuntime,
+				...human === void 0 ? {} : { human },
+				...driver === void 0 ? {} : { driver },
+				...args["run-id"] === void 0 ? {} : { runId: args["run-id"] },
+				out: write,
+				err: writeErr,
+				onRun: (handle) => {
+					onInterrupt(handle.interrupt);
+				}
+			});
+			if (!applied.ok) {
+				writeErr(applied.error);
+				process.exitCode = 1;
+				return;
+			}
+			const [first, ...rest] = applied.lines;
+			const mark = applied.outcome.kind === "kept" ? style("green", "✓") : style("yellow", "·");
+			write(`${mark} ${first ?? ""}`);
+			for (const line of rest) write(`  ${line}`);
+			if (applied.outcome.kind === "unfinished") process.exitCode = 1;
+		} finally {
+			human?.close();
+			store.close();
 		}
+	}
+});
+const triage = defineCommand({
+	meta: {
+		name: "triage",
+		description: "Merge new items about the same problem as others, asking about each"
 	},
+	args: { yes: {
+		type: "boolean",
+		description: "Make every merge without asking",
+		default: false
+	} },
 	run: ({ args }) => withStore(async (store) => {
-		const found = findRun(store, args.run, process.cwd());
+		if (!args.yes && !process.stdin.isTTY) {
+			writeErr("Pass --yes to triage without a terminal.");
+			process.exitCode = 1;
+			return;
+		}
+		const done = await triage$1(store, async (merge) => {
+			for (const line of formatMerge(merge)) write(line);
+			return args.yes || await confirm("Merge them? [y/N] ");
+		});
+		write(`${style("green", "✓")} ${triageSummary(done)}`);
+	})
+});
+const split = defineCommand({
+	meta: {
+		name: "split",
+		description: "Take apart the items triage merged into one"
+	},
+	args: { item: itemArg$1 },
+	run: ({ args }) => withStore((store) => {
+		const found = findFeedbackItem(store, args.item);
 		if (!found.ok) {
 			writeErr(found.error);
 			process.exitCode = 1;
 			return;
 		}
-		const abort = new AbortController();
-		process.once("SIGINT", () => {
-			abort.abort();
+		const moved = store.splitFeedback(found.item.id);
+		write(moved === 0 ? `Nothing was merged into ${found.item.id.slice(0, 12)}.` : `${style("green", "✓")} split ${String(moved)} item(s) back out of ${found.item.id.slice(0, 12)}`);
+	})
+});
+// src/runs/jsonl.ts
+/**
+* @file `ork feedback export` and `import` (specs/feedback.md): feedback
+*   records as JSON lines, one record a line, so a team can move feedback
+*   between machines without GitHub. A line is checked before it's added, and a
+*   record already here (its run and event) is skipped.
+*/
+const Text = z.string();
+const LineSchema = z.strictObject({
+	feedbackVersion: z.literal(1),
+	runId: z.string().min(1),
+	seq: z.number().int().nonnegative(),
+	at: z.string().min(1),
+	node: z.string().min(1).optional(),
+	feedback: z.strictObject({
+		source: z.enum([
+			"system",
+			"agent",
+			"human"
+		]),
+		kind: z.enum(FEEDBACK_KINDS),
+		target: z.enum(FEEDBACK_TARGETS),
+		severity: z.enum(FEEDBACK_SEVERITIES),
+		title: Text.min(1),
+		body: Text,
+		evidence: z.array(Text),
+		code: Text.optional(),
+		fingerprint: z.string().regex(/^[0-9a-f]{8,64}$/u),
+		origin: z.strictObject({
+			workflow: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/u).optional(),
+			workflowHash: Text.optional(),
+			nodeType: Text.optional(),
+			model: Text.optional(),
+			driver: Text.optional(),
+			version: Text.optional()
+		})
+	})
+});
+/** Records as JSON lines, with the format's version on each. */
+const exportLines = (records) => records.map(({ id: _id, ...record }) => JSON.stringify({
+	feedbackVersion: 1,
+	...record
+})).map((line) => `${line}\n`).join("");
+/** The records in a JSONL file's text, and what was wrong with the rest. */
+const parseLines = (text) => {
+	const records = [];
+	const problems = [];
+	for (const [index, line] of text.split("\n").entries()) {
+		if (line.trim() === "") continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			problems.push(`line ${String(index + 1)}: not JSON`);
+			continue;
+		}
+		const parsed = LineSchema.safeParse(value);
+		if (!parsed.success) {
+			const [issue] = parsed.error.issues;
+			problems.push(`line ${String(index + 1)}: ${issue?.path.join(".") ?? ""} ${issue?.message ?? "isn't a feedback record"}`.trim());
+			continue;
+		}
+		const { feedbackVersion: _version, node, feedback, ...rest } = parsed.data;
+		const { code, origin, ...report } = feedback;
+		records.push({
+			...rest,
+			...node === void 0 ? {} : { node },
+			feedback: {
+				...report,
+				...code === void 0 ? {} : { code },
+				origin: Object.fromEntries(Object.entries(origin).filter(([, v]) => v !== void 0))
+			}
 		});
-		await followRun(store, found.run, write, {
-			follow: args.follow,
-			json: args.json,
-			signal: abort.signal,
-			...args.node === void 0 ? {} : { node: args.node }
+	}
+	return {
+		records,
+		problems
+	};
+};
+// src/runs/publish.ts
+/** What will be sent, as the person reads it before saying yes. */
+const formatPreview = (post, plan) => plan.kind === "comment" ? [
+	`A thread for this exists (${plan.url}), so this comment goes on it:`,
+	"",
+	post.comment
+] : [
+	"A new thread in the Agent feedback category of mimshins/ork:",
+	"",
+	`Title: ${post.title}`,
+	"",
+	post.body
+];
+// src/commands/feedback-share.ts
+/**
+* @file The `ork feedback` subcommands that move feedback off this machine,
+*   only when the person says so (ADR-059): `publish` shares an item about Ork
+*   with its maintainers, through the person's own `gh`, after showing exactly
+*   what will be posted; `export` and `import` move records as JSON lines.
+*/
+const failed = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+const publish = defineCommand({
+	meta: {
+		name: "publish",
+		description: "Share an item about Ork with its maintainers, after showing exactly what goes"
+	},
+	args: {
+		item: {
+			type: "positional",
+			description: "A feedback item's id, or a prefix of one",
+			required: true
+		},
+		"hide-names": {
+			type: "boolean",
+			description: "Also hide the repositories' and workflows' names",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore(async (store) => {
+		if (!process.stdin.isTTY) {
+			failed("publish shows what it will post and asks you first: run it in a terminal.");
+			return;
+		}
+		const found = findFeedbackItem(store, args.item);
+		if (!found.ok) {
+			failed(found.error);
+			return;
+		}
+		const preview = previewPost(store, found.item, {
+			home: homedir(),
+			registered: registeredProjects(),
+			hideNames: args["hide-names"]
 		});
+		if (!preview.ok) {
+			failed(preview.error);
+			return;
+		}
+		const planned = await planPost(preview.post);
+		if (!planned.ok) {
+			failed(planned.error);
+			return;
+		}
+		for (const line of formatPreview(preview.post, planned.plan)) write(line);
+		write("");
+		if (!await confirm("Post it with your own gh login? [y/N] ")) {
+			write("Nothing was sent.");
+			return;
+		}
+		const sent = await sendPost(preview.post, planned.plan);
+		if (!sent.ok) {
+			failed(sent.error);
+			return;
+		}
+		store.setFeedbackStatus(found.item.id, "published");
+		write(`${style("green", "✓")} ${sent.kind === "created" ? "posted" : "added a +1 to"} ${sent.url}`);
 	})
 });
-const tree = defineCommand({
+const exportFeedback = defineCommand({
 	meta: {
-		name: "tree",
-		description: "Show a run's ownership tree with status, tokens and cost"
+		name: "export",
+		description: "Write feedback records as JSON lines, to share them"
 	},
 	args: {
-		run: runArg,
-		json: {
+		all: {
 			type: "boolean",
-			description: "Print JSON",
+			description: "Dismissed items' records too",
 			default: false
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "A file to write (default: the terminal)"
 		}
 	},
 	run: ({ args }) => withStore((store) => {
-		const found = findRun(store, args.run, process.cwd());
-		if (!found.ok) {
-			writeErr(found.error);
-			process.exitCode = 1;
+		const records = store.exportFeedback({ all: args.all });
+		const text = exportLines(records);
+		if (args.output === void 0) {
+			process.stdout.write(text);
 			return;
 		}
-		const { run } = found;
-		const events = store.events(run.id).map((s) => s.event);
-		const roots = runTree(events);
-		if (args.json) {
-			write(JSON.stringify(roots, void 0, 2));
+		writeFileSync(args.output, text);
+		write(`${style("green", "✓")} wrote ${String(records.length)} record(s) to ${args.output}`);
+	})
+});
+const importFeedback = defineCommand({
+	meta: {
+		name: "import",
+		description: "Add feedback records from a JSON-lines file"
+	},
+	args: { file: {
+		type: "positional",
+		description: "What `ork feedback export` wrote",
+		required: true
+	} },
+	run: ({ args }) => withStore((store) => {
+		let text;
+		try {
+			text = readFileSync(args.file, "utf8");
+		} catch {
+			failed(`Can't read ${args.file}.`);
 			return;
 		}
-		write(`${style("bold", `run ${run.id}`)} ${style("dim", `of ${run.workflow} · ${runStatus(run, events)} · ${cost(run.costUsd)}`)}`);
-		for (const line of formatTree(roots)) write(line);
+		const { records, problems } = parseLines(text);
+		const added = records.filter((r) => store.importFeedback(r)).length;
+		for (const problem of problems) writeErr(problem);
+		write(`${style("green", "✓")} added ${String(added)} record(s); ${String(records.length - added)} were here already${problems.length === 0 ? "" : `; ${String(problems.length)} line(s) left out`}`);
+		if (problems.length > 0) process.exitCode = 1;
 	})
 });
+// src/commands/feedback.ts
+/**
+* @file `ork feedback`: the feedback every run recorded, grouped into items
+*   (specs/feedback.md): list and show them, note a run, dismiss and restore an
+*   item, and accept one, as a lesson its workflow reads from then on. What
+*   closes the loop further (apply, triage, split) is in `feedback-loop.ts`,
+*   and what moves feedback off the machine (publish, export, import) in
+*   `feedback-share.ts`.
+*/
+/** Runs `body` on the item `prefix` names, or says why there's none. */
+const withItem = (prefix, body) => withStore((store) => {
+	const found = findFeedbackItem(store, prefix);
+	if (!found.ok) {
+		writeErr(found.error);
+		process.exitCode = 1;
+		return;
+	}
+	body(store, found.item);
+});
 const itemArg = {
 	type: "positional",
 	description: "A feedback item's id, or a prefix of one",
@@ -3467,7 +3626,7 @@ const json$1 = {
 const feedback = defineCommand({
 	meta: {
 		name: "feedback",
-		description: "What got in the way in your runs, grouped: list, show, note, dismiss, restore"
+		description: "What got in the way in your runs, grouped: list, show, note, triage, accept, apply, publish, export, import"
 	},
 	subCommands: {
 		list: defineCommand({
@@ -3498,22 +3657,16 @@ const feedback = defineCommand({
 				item: itemArg,
 				json: json$1
 			},
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				const records = store.feedbackRecords(found.item.id);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				const records = store.feedbackRecords(item.id);
 				if (args.json) {
 					write(JSON.stringify({
-						...found.item,
+						...item,
 						records
 					}, void 0, 2));
 					return;
 				}
-				for (const line of formatFeedbackItem(found.item, records)) write(line);
+				for (const line of formatFeedbackItem(item, records)) write(line);
 			})
 		}),
 		note: defineCommand({
@@ -3564,21 +3717,59 @@ const feedback = defineCommand({
 				process.exitCode = 1;
 			})
 		}),
+		accept: defineCommand({
+			meta: {
+				name: "accept",
+				description: "Accept an item; with --lesson, every later session of its workflow reads it"
+			},
+			args: {
+				item: itemArg,
+				lesson: {
+					type: "boolean",
+					description: "Add it to the workflow's lessons (.ork/lessons/<workflow>.md)",
+					default: false
+				},
+				message: {
+					type: "string",
+					alias: "m",
+					description: "The lesson's words (default: the item's title)"
+				},
+				workflow: {
+					type: "string",
+					description: "Whose lessons, when it was seen in more than one"
+				}
+			},
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				const accepted = acceptItem(store, item, {
+					lesson: args.lesson,
+					text: args.message,
+					workflow: args.workflow
+				}, registeredProjects());
+				if (!accepted.ok) {
+					writeErr(accepted.error);
+					process.exitCode = 1;
+					return;
+				}
+				const [first, ...rest] = accepted.lines;
+				write(`${style("green", "✓")} ${first ?? ""}`);
+				for (const line of rest) write(`  ${line}`);
+			})
+		}),
+		apply,
+		triage,
+		split,
+		publish,
+		export: exportFeedback,
+		import: importFeedback,
 		dismiss: defineCommand({
 			meta: {
 				name: "dismiss",
 				description: "Dismiss an item: it leaves the list, and stays dismissed"
 			},
 			args: { item: itemArg },
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				store.setFeedbackStatus(found.item.id, "dismissed");
-				write(`${style("green", "✓")} dismissed ${found.item.id}: ${found.item.title}`);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				store.setFeedbackStatus(item.id, "dismissed");
+				write(`${style("green", "✓")} dismissed ${item.id}: ${item.title}`);
 			})
 		}),
 		restore: defineCommand({
@@ -3587,19 +3778,128 @@ const feedback = defineCommand({
 				description: "Bring a dismissed item back to the list, as new"
 			},
 			args: { item: itemArg },
-			run: ({ args }) => withStore((store) => {
-				const found = findFeedbackItem(store, args.item);
-				if (!found.ok) {
-					writeErr(found.error);
-					process.exitCode = 1;
-					return;
-				}
-				store.setFeedbackStatus(found.item.id, "new");
-				write(`${style("green", "✓")} restored ${found.item.id}: ${found.item.title}`);
+			run: ({ args }) => withItem(args.item, (store, item) => {
+				store.setFeedbackStatus(item.id, "new");
+				write(`${style("green", "✓")} restored ${item.id}: ${item.title}`);
 			})
 		})
 	}
 });
+// src/commands/runs.ts
+/**
+* @file `ork ps`, `ork logs` and `ork tree`: read what every project's runs
+*   recorded in `~/.ork/state.db` (specs/event-store.md).
+*/
+const ps = defineCommand({
+	meta: {
+		name: "ps",
+		description: "List this project's runs, newest first"
+	},
+	args: {
+		all: {
+			type: "boolean",
+			description: "Every project's runs",
+			default: false
+		},
+		limit: {
+			type: "string",
+			description: "How many (default 20)"
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore((store) => {
+		const limit = Number(args.limit ?? 20);
+		const runs = store.runs({
+			limit: Number.isInteger(limit) && limit > 0 ? limit : 20,
+			...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root }
+		});
+		const statusOf = (run) => runStatus(run, run.status === "running" ? store.events(run.id).map((s) => s.event) : []);
+		if (args.json) write(JSON.stringify(runs, void 0, 2));
+		else for (const line of formatRuns(runs, args.all, Date.now(), statusOf)) write(line);
+	})
+});
+const runArg = {
+	type: "positional",
+	description: "A run id or a prefix of one (default: this project's newest)",
+	required: false
+};
+const logs = defineCommand({
+	meta: {
+		name: "logs",
+		description: "Print a run's transcript"
+	},
+	args: {
+		run: runArg,
+		node: {
+			type: "string",
+			description: "Only this node's events"
+		},
+		follow: {
+			type: "boolean",
+			alias: "f",
+			description: "Keep printing a live run's events until it ends",
+			default: false
+		},
+		json: {
+			type: "boolean",
+			description: "Print the stored events as JSON lines",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore(async (store) => {
+		const found = findRun(store, args.run, process.cwd());
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const abort = new AbortController();
+		process.once("SIGINT", () => {
+			abort.abort();
+		});
+		await followRun(store, found.run, write, {
+			follow: args.follow,
+			json: args.json,
+			signal: abort.signal,
+			...args.node === void 0 ? {} : { node: args.node }
+		});
+	})
+});
+const tree = defineCommand({
+	meta: {
+		name: "tree",
+		description: "Show a run's ownership tree with status, tokens and cost"
+	},
+	args: {
+		run: runArg,
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => withStore((store) => {
+		const found = findRun(store, args.run, process.cwd());
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const { run } = found;
+		const events = store.events(run.id).map((s) => s.event);
+		const roots = runTree(events);
+		if (args.json) {
+			write(JSON.stringify(roots, void 0, 2));
+			return;
+		}
+		write(`${style("bold", `run ${run.id}`)} ${style("dim", `of ${run.workflow} · ${runStatus(run, events)} · ${cost(run.costUsd)}`)}`);
+		for (const line of formatTree(roots)) write(line);
+	})
+});
 // src/agents/manage.ts
 /**
 * @file What `ork agents` prints and does: the catalog as a table, one agent in
@@ -3904,23 +4204,23 @@ const main = defineCommand({
 		ps,
 		logs,
 		tree,
-		usage: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.usage),
-		prune: () => import("./usage-BIjf9Xdt.mjs").then((module) => module.prune),
+		usage: () => import("./usage-CT7Z-yjr.mjs").then((module) => module.usage),
+		prune: () => import("./usage-CT7Z-yjr.mjs").then((module) => module.prune),
 		decide,
-		relay: () => import("./relay-CbK-Wme9.mjs").then((module) => module.relay),
-		pause: () => import("./pause-DKACDfV1.mjs").then((module) => module.pause),
-		continue: () => import("./pause-DKACDfV1.mjs").then((module) => module.continueRun),
+		relay: () => import("./relay-Do-aNbSD.mjs").then((module) => module.relay),
+		pause: () => import("./pause-BPSmg4yz.mjs").then((module) => module.pause),
+		continue: () => import("./pause-BPSmg4yz.mjs").then((module) => module.continueRun),
 		stop,
 		chat,
-		send: () => import("./send-C6yr04Fe.mjs").then((module) => module.send),
+		send: () => import("./send-DhGBkowy.mjs").then((module) => module.send),
 		resume,
 		feedback,
 		context,
-		worktrees,
-		wt: worktrees,
-		watch: () => import("./watch-B8o4Szd_.mjs").then((module) => module.watch),
-		mcp: () => import("./mcp-BWsdQyri.mjs").then((module) => module.mcp),
-		ui: () => import("./ui-CZS1XKla.mjs").then((module) => module.ui),
+		worktrees: () => import("./worktrees-DHl80k96.mjs").then((module) => module.worktrees),
+		wt: () => import("./worktrees-DHl80k96.mjs").then((module) => module.worktrees),
+		watch: () => import("./watch-0Qr2UfCQ.mjs").then((module) => module.watch),
+		mcp: () => import("./mcp-CHVKKg3B.mjs").then((module) => module.mcp),
+		ui: () => import("./ui-DhutUMgQ.mjs").then((module) => module.ui),
 		doctor,
 		upgrade
 	}