@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/README.md

@@ -3,29 +3,33 @@
 The `ork` command: orchestrate Claude agents on your machine with hierarchical,
 serializable workflows.
 
-> **Pre-alpha.** The workflow format, `ork run` with delegation and worktrees,
-> the context compiler, agents, run logs, decisions from any terminal, messages
-> between nodes, chat, resume, claims and local feedback work today; a web UI
-> comes next. Expect changes between 0.x releases. See the
-> [project README](https://github.com/mimshins/ork#readme) and the
-> [guides](https://github.com/mimshins/ork/tree/main/docs#readme).
+> **Pre-alpha.** Workflows of Claude agents and tools, run from the terminal or
+> the browser (`ork ui`). Expect changes between 0.x releases. See the
+> [project README](https://github.com/mimshins/ork#readme), the
+> [guides](https://github.com/mimshins/ork/tree/main/docs#readme) and
+> [what's new](https://github.com/mimshins/ork/blob/main/docs/whats-new.md).
+
+Rather have your coding agent set it up? See
+[With your agent](https://github.com/mimshins/ork/blob/main/docs/getting-started/with-your-agent.md).
 
 ```sh
 npm install --global @krapht/ork
 
 ork doctor              # node, git, and your own claude / gh / aws logins
-ork init                # scaffold .ork/ with a starter workflow
+ork init                # .ork/ with a starter workflow
 ork validate            # check .ork/workflows/*.ork.yaml
 ork run hello --input task="add a README"
                         # run the workflow; questions come to the terminal
-ork worktrees           # the worktrees and branches runs left; `clean` tidies up
-ork run hello --node lead --input task="add a README" --in-place
-                        # run one Claude node on its own
+ork ui                  # your runs in the browser
+ork worktrees           # the worktrees and branches runs left
+ork worktrees clean     # removes the merged ones; asks first
 ork upgrade             # a newer version? upgrade the way you installed Ork
 ```
 
-`--driver sdk` (the default) needs `ANTHROPIC_API_KEY` or a cloud provider;
-`--driver cli` uses your own logged-in `claude`.
+A workflow that names no Claude driver runs on the one that's ready: the CLI
+driver uses your own logged-in `claude`; the SDK driver needs
+`ANTHROPIC_API_KEY` or a cloud provider. `--driver cli` or `--driver sdk` picks
+one.
 
 Ork never stores or asks for credentials: it uses the tools you already have,
 signed in with your own accounts. Once a day it asks the npm registry whether a

package/dist/__build_info__-DdTVd2p5.mjs

@@ -0,0 +1,615 @@
+import { An as guardedBase, En as inside, Gt as publishPost, Mn as writePlainFile, On as LESSON_CAP_TOKENS, Rt as FEEDBACK_KINDS, Yt as targetOf, Zt as maskSecrets, bn as placeFiles, g as parseVersion, h as isNewer, jn as plainPathInside, kn as estimateTokens, m as compareVersions, qt as fingerprint, xn as placeFor, zt as FEEDBACK_SEVERITIES } from "./src-DHvWU4tX.mjs";
+import path from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+// ../core/src/feedback/actions.ts
+const ALLOWED = { ok: true };
+const no = (why, error) => ({
+	ok: false,
+	why,
+	error
+});
+/** A dismissed item allows nothing until it's restored. */
+const dismissed = (short) => no("dismissed; restore it first", `${short} is dismissed; restore it first.`);
+const already = (short, status) => no(`${status} already`, `${short} is ${status} already.`);
+/**
+* `fixRun` is a running `ork:feedback-apply` run for the item ({@link
+* openFixRun}): a second fix isn't started beside it.
+*/
+const feedbackActions = (item, fixRun) => {
+	const short = item.id.slice(0, 12);
+	const isOrk = item.target === "ork";
+	if (item.status === "dismissed") {
+		const check = dismissed(short);
+		return {
+			accept: check,
+			lesson: check,
+			apply: check,
+			publish: check
+		};
+	}
+	const settled = item.status === "resolved" || item.status === "published";
+	const accept = item.status === "accepted" || settled ? already(short, item.status) : ALLOWED;
+	let lesson = ALLOWED;
+	if (isOrk) lesson = no("about Ork itself", `${short} is about Ork itself, so it isn't a lesson for a workflow; share it with Ork's maintainers instead.`);
+	else if (item.workflows.length === 0) lesson = no("no workflow recorded, so no lessons file", `No workflow is recorded for ${short}, so it has no lessons file.`);
+	let apply = ALLOWED;
+	if (isOrk) apply = no("about Ork itself", `${short} is about Ork itself, so its fix isn't in this project; share it with Ork's maintainers instead.`);
+	else if (settled) apply = already(short, item.status);
+	else if (fixRun !== void 0) apply = no(`run ${fixRun} is proposing a fix`, `Run ${fixRun} is proposing a fix for ${short} already: answer its question in \`ork decide\` or the UI, or stop it first.`);
+	let publish = ALLOWED;
+	if (!isOrk) publish = no("only feedback about Ork is shared", `${short} is about this ${item.target}, not Ork itself: only feedback about Ork is shared, and the rest stays on your machine.`);
+	else if (item.status === "published") publish = already(short, item.status);
+	return {
+		accept,
+		lesson,
+		apply,
+		publish
+	};
+};
+/** The running `ork:feedback-apply` run proposing a fix for `item`, if any. */
+const openFixRun = (store, item) => {
+	const short = item.id.slice(0, 12);
+	return store.runs().filter((run) => run.workflow === "ork-feedback-apply" && run.status === "running").find((run) => {
+		const [first] = store.events(run.id);
+		const event = first?.event;
+		return event?.type === "run.started" && event.inputs?.["item"] === short;
+	})?.id;
+};
+// ../core/src/feedback/lessons.ts
+/**
+* @file Accepting a feedback item as a lesson (specs/feedback.md, ADR-059): one
+*   line in the workflow's `.ork/lessons/<workflow>.md`, marked with the item
+*   it came from so it isn't added twice, and refused when it would take the
+*   file past the cap a session loads, or when the file, or a folder on the way
+*   to it, is a link a cloned repository could aim at the person's own files.
+*   Only a person's acceptance writes one: feedback is model output that
+*   repository content can steer.
+*/
+/** A workflow's name, as the format allows it: never a path. */
+const SLUG = /^[a-z0-9][a-z0-9._-]*$/u;
+/** A workflow's lessons file in a project. */
+const lessonsFileOf = (place, workflow) => path.join(placeFiles(place).lessons, `${workflow}.md`);
+/** What marks a lesson with its item, in the file. */
+const lessonMark = (item) => `<!-- feedback ${item.slice(0, 12)} -->`;
+/** The lesson as one list entry, its later lines indented under the first. */
+const entryOf = (text, item) => {
+	const [first = "", ...rest] = text.trim().split("\n").map((line) => line.trimEnd());
+	return [`- ${first} ${lessonMark(item)}`, ...rest.map((l) => `  ${l}`)].join("\n").concat("\n");
+};
+/** Adds a lesson to its workflow's file, or says why it can't. */
+const addLesson = (ask) => {
+	if (ask.text.trim() === "") return {
+		ok: false,
+		error: "The lesson is empty."
+	};
+	if (!SLUG.test(ask.workflow) || !plainPathInside(ask.base, ask.file)) return {
+		ok: false,
+		error: `${ask.shownAs} is a link, or behind one, or outside the project: Ork writes lessons only to a plain file there, so it wrote nothing.`
+	};
+	const current = existsSync(ask.file) ? readFileSync(ask.file, "utf8") : `# Lessons for ${ask.workflow}\n\n`;
+	if (current.includes(lessonMark(ask.item))) return {
+		ok: false,
+		error: `${ask.item.slice(0, 12)} is already a lesson in ${ask.shownAs}.`
+	};
+	const next = `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}${entryOf(ask.text, ask.item)}`;
+	const tokens = estimateTokens(next);
+	if (tokens > 1500) return {
+		ok: false,
+		error: `${ask.shownAs} would be about ${tokens.toLocaleString("en")} tokens, over the ${LESSON_CAP_TOKENS.toLocaleString("en")} a session loads. Edit it to make room, then accept again.`
+	};
+	const written = writePlainFile(ask.base, ask.file, next, ask.shownAs);
+	return written.ok ? {
+		ok: true,
+		tokens
+	} : written;
+};
+// ../core/src/feedback/accept.ts
+/**
+* @file Accepting a feedback item (`ork feedback accept`, the Feedback panel):
+*   marks an item accepted and, with `--lesson`, writes it as a lesson into the
+*   lessons file of the workflow it was seen in, in the project of its newest
+*   record there (ADR-059). An `ork` item is about Ork itself, so it's never a
+*   lesson: it can be published instead.
+*/
+const listed = (names) => names.map((n) => `\`${n}\``).join(", ");
+/** The workflow a lesson is for: the one named, or the only one it was seen in. */
+const workflowFor = (item, named) => {
+	if (named !== void 0) return item.workflows.includes(named) ? {
+		ok: true,
+		workflow: named
+	} : {
+		ok: false,
+		error: `${item.id.slice(0, 12)} wasn't seen in \`${named}\`, only in ${listed(item.workflows)}.`
+	};
+	const [only, other] = item.workflows;
+	if (only === void 0) return {
+		ok: false,
+		error: `No workflow is recorded for ${item.id.slice(0, 12)}, so it has no lessons file.`
+	};
+	return other === void 0 ? {
+		ok: true,
+		workflow: only
+	} : {
+		ok: false,
+		error: `${item.id.slice(0, 12)} was seen in ${listed(item.workflows)}: name one with --workflow.`
+	};
+};
+const real = (dir) => {
+	try {
+		return realpathSync(dir);
+	} catch {
+		return path.resolve(dir);
+	}
+};
+/**
+* The project of the item's newest record (in `workflow`, when given): the
+* folder its run started in, when that's still the same project. A clone that
+* was deleted is refused, never taken for a repository above it.
+*/
+const placeOf = (store, item, workflow, registered) => {
+	const record = store.feedbackRecords(item.id).findLast((r) => workflow === void 0 || r.feedback.origin.workflow === workflow);
+	const [run] = record === void 0 ? [] : store.lookup(record.runId);
+	if (run === void 0) return {
+		ok: false,
+		error: `The runs ${item.id.slice(0, 12)} was seen in are gone, so its project isn't known.`
+	};
+	if (!existsSync(run.project)) return {
+		ok: false,
+		error: `Its project at ${run.project} is gone.`
+	};
+	const folder = path.dirname(run.file);
+	const place = placeFor(existsSync(folder) ? folder : run.project, registered);
+	return real(place.root) === real(run.project) ? {
+		ok: true,
+		place,
+		project: run.project
+	} : {
+		ok: false,
+		error: `Its project at ${run.project} isn't a project any more: Ork would take it for ${place.root}.`
+	};
+};
+/** Accepts `item`, as a lesson with `--lesson`. */
+const acceptItem = (store, item, args, registered) => {
+	const name = `${item.id.slice(0, 12)}: ${item.title}`;
+	const actions = feedbackActions(item);
+	if (!args.lesson) {
+		if (!actions.accept.ok) return {
+			ok: false,
+			error: actions.accept.error
+		};
+		store.setFeedbackStatus(item.id, "accepted");
+		return {
+			ok: true,
+			lines: [`accepted ${name}`]
+		};
+	}
+	if (!actions.lesson.ok) return {
+		ok: false,
+		error: actions.lesson.error
+	};
+	const chosen = workflowFor(item, args.workflow);
+	if (!chosen.ok) return chosen;
+	const found = placeOf(store, item, chosen.workflow, registered);
+	if (!found.ok) return found;
+	const { place } = found;
+	const file = lessonsFileOf(place, chosen.workflow);
+	const shownAs = inside(place.root, file) ? path.relative(place.root, file) : file;
+	const added = addLesson({
+		file,
+		base: guardedBase(place),
+		shownAs,
+		workflow: chosen.workflow,
+		item: item.id,
+		text: args.text ?? item.title
+	});
+	if (!added.ok) return added;
+	if (actions.accept.ok) store.setFeedbackStatus(item.id, "accepted");
+	return {
+		ok: true,
+		lesson: {
+			file: shownAs,
+			root: place.root,
+			workflow: chosen.workflow,
+			tokens: added.tokens
+		},
+		lines: [`accepted ${name}`, `lesson added to ${shownAs} in ${place.root} (about ${added.tokens.toLocaleString("en")} of ${LESSON_CAP_TOKENS.toLocaleString("en")} tokens); every session of \`${chosen.workflow}\` reads it from now on`]
+	};
+};
+const lessonPlaceOf = (store, item, workflow, registered) => {
+	const found = placeOf(store, item, workflow, registered);
+	if (!found.ok) return {
+		ok: false,
+		workflow,
+		error: found.error
+	};
+	const { place } = found;
+	const file = lessonsFileOf(place, workflow);
+	const exists = existsSync(file);
+	return {
+		ok: true,
+		workflow,
+		file: inside(place.root, file) ? path.relative(place.root, file) : file,
+		root: place.root,
+		tokens: exists ? estimateTokens(readFileSync(file, "utf8")) : 0,
+		exists
+	};
+};
+// ../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
+	};
+};
+/** `value` when it's one of `allowed`, or why not. */
+const checked = (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
+	};
+};
+/**
+* Whether a note can be recorded, before anything else is done: its words,
+* kind, severity and rating. `flag` names the options as the caller does (`--`
+* for the CLI).
+*/
+const checkNote = (ask, flag = "") => {
+	if (ask.text.trim() === "") return {
+		ok: false,
+		error: "The note is empty."
+	};
+	const kind = checked(`${flag}kind`, ask.kind, FEEDBACK_KINDS);
+	const severity = checked(`${flag}severity`, ask.severity, FEEDBACK_SEVERITIES);
+	const rating = checked(`${flag}rating`, ask.rating, RATINGS);
+	if (!kind.ok) return kind;
+	if (!severity.ok) return severity;
+	if (!rating.ok) return rating;
+	return {
+		ok: true,
+		...kind.value === void 0 ? {} : { kind: kind.value },
+		...severity.value === void 0 ? {} : { severity: severity.value },
+		...rating.value === void 0 ? {} : { rating: rating.value }
+	};
+};
+/**
+* Records a person's note on `run`, or one node that ran in it, as that run's
+* feedback (a run that ended takes it too); returns the item it joins (the one
+* it was merged into, when triage merged it), or why it can't. `ork feedback
+* note`, `ork decide --note` and the UI write it.
+*/
+const recordNote = (store, run, ask, flag = "") => {
+	const note = checkNote(ask, flag);
+	if (!note.ok) return note;
+	const ran = store.events(run.id).some(({ event }) => "id" in event && event.id === ask.node);
+	if (ask.node !== void 0 && !ran) return {
+		ok: false,
+		error: `No node ${ask.node} ran in run ${run.id}.`
+	};
+	const event = humanNoteEvent({
+		text: ask.text,
+		workflow: run.workflow,
+		...ask.node === void 0 ? {} : { node: ask.node },
+		...note.kind === void 0 ? {} : { kind: note.kind },
+		...note.severity === void 0 ? {} : { severity: note.severity },
+		...note.rating === void 0 ? {} : { rating: note.rating }
+	});
+	store.append(run.id, event);
+	const recorded = event.type === "feedback.recorded" ? event.feedback.fingerprint : "";
+	return {
+		ok: true,
+		item: store.findFeedback(recorded)[0]?.id ?? recorded
+	};
+};
+// ../core/src/feedback/preview.ts
+/**
+* @file The preview of an `ork` item as a post to Ork's Discussions (ADR-059),
+*   for `ork feedback publish` and the Feedback panel. The projects its records
+*   came from and every registered one are rewritten to `<project>`, and when
+*   names are hidden their folders' and the workflows' names go too. What the
+*   person confirms is what is sent.
+*/
+/** The item as a post, or why it isn't shared. */
+const previewPost = (store, item, ask) => {
+	const allowed = feedbackActions(item).publish;
+	if (!allowed.ok) return {
+		ok: false,
+		error: allowed.error
+	};
+	const records = store.feedbackRecords(item.id);
+	const runRoots = records.flatMap((r) => store.lookup(r.runId).find((run) => run.id === r.runId)?.project ?? []);
+	const roots = [.../* @__PURE__ */ new Set([...runRoots, ...ask.registered.map((p) => p.root)])];
+	const names = ask.hideNames ? [...item.workflows, ...roots.map((root) => path.basename(root))] : [];
+	return {
+		ok: true,
+		post: publishPost(item, records, {
+			roots,
+			home: ask.home,
+			names
+		})
+	};
+};
+// ../core/src/remote/session.ts
+const chattable = (type) => type === "claude.leader" || type === "claude.worker";
+/** Reads `node`'s session from a run's events, and every node's last output. */
+const nodeSession = (events, node) => {
+	const session = {
+		known: false,
+		chattable: false,
+		running: false
+	};
+	const outputs = {};
+	for (const { event } of events) {
+		if (event.type === "run.started") {
+			const declared = event.nodes.find((n) => n.id === node);
+			if (declared !== void 0) {
+				session.known = true;
+				session.chattable = chattable(declared.type);
+			}
+		}
+		if (event.type === "node.finished") outputs[event.id] = event.output;
+		if (!("id" in event) || event.id !== node) continue;
+		if (event.type === "node.started") {
+			session.known = true;
+			session.chattable = chattable(event.nodeType);
+			session.running = true;
+		}
+		if (event.type === "node.finished") session.running = false;
+		if (event.type === "worktree" && event.action === "created") session.checkout = {
+			path: event.path,
+			...event.branch === void 0 ? {} : { branch: event.branch },
+			own: true,
+			owner: node
+		};
+		if (event.type !== "node.event") continue;
+		const inner = event.event;
+		if (inner.fork === true) continue;
+		if (inner.type === "session.started") {
+			session.sessionId = inner.sessionId;
+			if (inner.cwd !== void 0) session.cwd = inner.cwd;
+			if (inner.driver !== void 0) session.driver = inner.driver;
+		}
+		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
+	}
+	return {
+		session,
+		outputs
+	};
+};
+/** The dist-tags every install follows, toward and after 1.0.0. */
+const CHANNEL_TAGS = [
+	"latest",
+	"alpha",
+	"beta",
+	"rc"
+];
+/** The dist-tag of snapshots from `main`, followed only by a canary. */
+const CANARY_TAG = "canary";
+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;
+/** Whether `version` is a canary snapshot: its pre-release starts `canary`. */
+const isCanary = (version) => parseVersion(version)?.pre[0]?.startsWith(CANARY_TAG) === true;
+/**
+* The newest version, by semver precedence, among the dist-tags `current`
+* follows: the channel tags, and `canary` too when `current` is a canary. A tag
+* whose value doesn't parse is skipped; `null` when none does.
+*/
+const newestTagged = (tags, current) => {
+	return (current !== void 0 && isCanary(current) ? [...CHANNEL_TAGS, "canary"] : CHANNEL_TAGS).flatMap((tag) => {
+		const value = tags[tag];
+		const version = typeof value === "string" ? parseVersion(value) : null;
+		return typeof value === "string" && version !== null ? [{
+			value,
+			version
+		}] : [];
+	}).reduce((best, candidate) => best === null || compareVersions(candidate.version, best.version) > 0 ? candidate : best, null)?.value ?? null;
+};
+/**
+* The newest version on the registry that the running version follows ({@link
+* newestTagged}), 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) ? newestTagged(tags, options.current) : 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 version is kept. `options.current` is the running version.
+*/
+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;
+};
+/**
+* Runs the command; resolves its exit code. Without `onOutput` it writes on the
+* terminal.
+*/
+const runInstall = (argv, onOutput) => new Promise((resolve) => {
+	const [program = "", ...args] = argv;
+	const child = spawn(program, args, { stdio: onOutput === void 0 ? "inherit" : [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	for (const stream of ["stdout", "stderr"]) {
+		child[stream]?.setEncoding("utf8");
+		child[stream]?.on("data", (text) => {
+			onOutput?.(stream, text);
+		});
+	}
+	child.on("error", (error) => {
+		const line = `Could not run ${program}: ${error.message}\n`;
+		if (onOutput === void 0) process.stderr.write(line);
+		else onOutput("stderr", line);
+		resolve(127);
+	});
+	child.on("close", (code) => {
+		resolve(code ?? 1);
+	});
+});
+// ../core/src/update/switches.ts
+/**
+* @file The environment's say over the update check (ADR-038): the variables
+*   that turn it off (`ORK_NO_UPDATE_CHECK`, the common `NO_UPDATE_NOTIFIER`,
+*   and `CI`), and the registry to ask instead of npm's. The CLI adds its own
+*   rules about where a notice may go; the server behind `ork ui` uses only
+*   these.
+*/
+/** Turns the automatic check and its notice off. */
+const NO_UPDATE_ENV = "ORK_NO_UPDATE_CHECK";
+/** A registry to ask instead of npm's, e.g. a company mirror. */
+const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
+/** The variables that turn the check off, in the order they are looked at. */
+const UPDATE_SWITCHES = [
+	NO_UPDATE_ENV,
+	"NO_UPDATE_NOTIFIER",
+	"CI"
+];
+/** Set to anything but empty, `0` or `false`. */
+const isSwitchedOn = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+/** The variable that turns the check off in `env`, or `null` when none does. */
+const updateSwitchOff = (env) => UPDATE_SWITCHES.find((name) => isSwitchedOn(env[name])) ?? null;
+/** The registry `ORK_UPDATE_REGISTRY` names, if it names one. */
+const registryOf = (env) => {
+	const registry = env[UPDATE_REGISTRY_ENV];
+	return registry === void 0 || registry === "" ? void 0 : registry;
+};
+/** The host of a registry that isn't an http(s) URL, past any `user:pass@`. */
+const hostOf = (registry) => registry.replace(/^[a-z][\w+.-]*:\/\//iu, "").replace(/^[^/?#]*@/u, "").split(/[/?#]/u)[0] ?? "";
+/**
+* The registry as it may be shown (on a page, in a message): an http(s) URL
+* without its user name and password, which a mirror's URL may carry; anything
+* else only as its host.
+*/
+const registryShown = (registry) => {
+	try {
+		const url = new URL(registry);
+		if (url.protocol === "http:" || url.protocol === "https:") {
+			if (url.username === "" && url.password === "") return registry;
+			url.username = "";
+			url.password = "";
+			return url.href;
+		}
+	} catch {}
+	return hostOf(registry);
+};
+// src/__build_info__.ts
+/**
+* @file The published package's name and version, bound to
+*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
+*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
+*   fails when it is stale.
+*/
+const ORK_NAME = "@krapht/ork";
+const ORK_VERSION = "1.0.0-alpha.0";
+export { feedbackActions as C, placeOf as S, previewPost as _, registryShown as a, acceptItem as b, checkDue as c, pendingNotice as d, readUpdateCache as f, nodeSession as g, writeUpdateCache as h, registryOf as i, fetchLatest as l, updateCachePath as m, ORK_VERSION as n, updateSwitchOff as o, refreshUpdateCache as p, isSwitchedOn as r, runInstall as s, ORK_NAME as t, newerVersion as u, checkNote as v, openFixRun as w, lessonPlaceOf as x, recordNote as y };