@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/format-BB4E-T6x.mjs

@@ -0,0 +1,249 @@
+import { Fn as lockWaitsOf, Hn as isItem, Ln as runStatus, Nt as lockWaitLine, Pn as liveStatus, Rn as slotWaitsOf, kr as maskSecrets } from "./src-8cOPOgrT.mjs";
+import { C as termOf, E as widthOf, n as cost, o as shortCount, r as costOf, s as style, w as cut } from "./output-B1kwo0YU.mjs";
+import { i as statusChip, n as chip } from "./chips-BqcT58qr.mjs";
+import { n as nodeVerdict } from "./verdict-CMvPCpWC.mjs";
+// src/term/table.ts
+/**
+* @file Aligned columns for the listing commands: each column as wide as its
+*   widest cell, a two-space gap, the last column left unpadded. Rich, a cell
+*   may be a chip and a table wider than the screen cuts its flexible columns
+*   with `…`; plain, nothing is cut or styled, as the listings always printed.
+*/
+/** A dimmed header cell. */
+const header = (text) => ({
+	text,
+	look: (s) => style("dim", s)
+});
+const GAP = "  ";
+/** A flexible column is never cut under this many columns. */
+const MIN_FLEX = 8;
+/** The text a cell shows, and its columns. */
+const shown = (term, cell) => term.rich && cell.chip !== void 0 ? cell.chip.label : cell.text;
+const widthOfCell = (term, cell) => widthOf(shown(term, cell)) + (term.rich && cell.chip !== void 0 ? 2 : 0);
+/** The lines of a table, one per row (a header is a row the caller passes). */
+const table = (term, columns, rows, indent = "") => {
+	const widths = columns.map((_, c) => Math.max(0, ...rows.map((row) => widthOfCell(term, row[c] ?? { text: "" }))));
+	if (term.rich) {
+		const gaps = 2 * (columns.length - 1);
+		let over = indent.length + widths.reduce((a, b) => a + b, 0) + gaps - term.width;
+		columns.forEach((column, c) => {
+			const width = widths[c] ?? 0;
+			if (over <= 0 || column.flex !== true || width <= MIN_FLEX) return;
+			const next = Math.max(MIN_FLEX, width - over);
+			over -= width - next;
+			widths[c] = next;
+		});
+	}
+	const last = columns.length - 1;
+	return rows.map((row) => indent + columns.map((column, c) => {
+		const cell = row[c] ?? { text: "" };
+		const width = widths[c] ?? 0;
+		const look = cell.look ?? ((s) => s);
+		if (term.rich && cell.chip !== void 0) {
+			const used = widthOfCell(term, cell);
+			const pad = " ".repeat(Math.max(0, width - used));
+			return column.align === "right" ? pad + chip(term, cell.chip.label, cell.chip.role) : chip(term, cell.chip.label, cell.chip.role) + (c === last ? "" : pad);
+		}
+		const text = cut(shown(term, cell), width);
+		const pad = " ".repeat(Math.max(0, width - widthOf(text)));
+		if (column.align === "right") return look(pad + text);
+		return c === last ? look(text) : look(text + pad);
+	}).join(GAP));
+};
+// src/runs/format.ts
+/**
+* @file How stored runs read on the terminal: the `ork ps` table and the `ork
+*   tree` ownership tree with each node's state, tokens and cost, and what is
+*   paused (ADR-041).
+*/
+const STATUS_STYLE = {
+	running: "cyan",
+	paused: "yellow",
+	succeeded: "green",
+	failed: "red",
+	crashed: "red",
+	budget_exhausted: "yellow",
+	quota_exhausted: "yellow",
+	timed_out: "yellow",
+	interrupted: "yellow"
+};
+/** `just now`, `5m ago`, `3h ago`, `2d ago`, then the date. */
+const ago = (iso, now = Date.now()) => {
+	const minutes = Math.floor((now - Date.parse(iso)) / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${String(minutes)}m ago`;
+	if (minutes < 1440) return `${String(Math.floor(minutes / 60))}h ago`;
+	if (minutes < 10080) return `${String(Math.floor(minutes / 1440))}d ago`;
+	return iso.slice(0, 10);
+};
+/** `42s`, `3m12s`, `1h05m`. */
+const duration = (ms) => {
+	const s = Math.max(0, Math.round(ms / 1e3));
+	if (s < 60) return `${String(s)}s`;
+	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
+	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
+};
+const dim = (s) => style("dim", s);
+/**
+* A run's status as `ork ps` reads it: for a running run, `waiting for <lock>,
+* held by <run>/<node>` with a node waiting for a lock, or `waiting for slot`
+* with a command waiting for a machine-wide slot; `events` are a running
+* run's.
+*/
+const listedStatus = (run, events) => {
+	const status = runStatus(run, events);
+	if (status !== "running") return status;
+	const [lock] = lockWaitsOf(events);
+	if (lock !== void 0) return lockWaitLine(lock.lock, lock.holders);
+	return slotWaitsOf(events).length > 0 ? "waiting for slot" : status;
+};
+/**
+* The `ork ps` table; `withProject` adds each run's project. A called run's
+* cost is dimmed and says its caller's, whose cost already counts it.
+*/
+const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus, term = termOf(process.stdout)) => {
+	if (runs.length === 0) return ["No runs."];
+	const rows = runs.map((run) => {
+		const status = statusOf(run);
+		const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
+		return {
+			id: run.id,
+			workflow: run.workflow,
+			status,
+			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
+			cost: run.parent === void 0 ? costOf(run.costUsd, run.partial, run.tokens) : `${costOf(run.costUsd, run.partial, run.tokens)} in ${run.parent}`,
+			called: run.parent !== void 0,
+			project: run.project
+		};
+	});
+	const rowOf = (r) => {
+		const cells = [
+			{
+				text: r.id,
+				look: (s) => style("bold", s)
+			},
+			{ text: r.workflow },
+			{
+				text: r.status,
+				chip: statusChip(r.status),
+				look: (s) => style(STATUS_STYLE[r.status] ?? "reset", s)
+			},
+			{
+				text: r.when,
+				look: dim
+			},
+			r.called ? {
+				text: r.cost,
+				look: dim
+			} : { text: r.cost }
+		];
+		if (withProject) cells.push({
+			text: r.project,
+			look: dim
+		});
+		return cells;
+	};
+	const heads = [
+		"RUN",
+		"WORKFLOW",
+		"STATUS",
+		"STARTED",
+		"COST"
+	].map((text) => header(text));
+	if (withProject) heads.push(header("PROJECT"));
+	const columns = [
+		{},
+		{ flex: true },
+		{},
+		{},
+		{ align: "right" }
+	];
+	if (withProject) columns.push({ flex: true });
+	return table(term, columns, [heads, ...rows.map((row) => rowOf(row))]);
+};
+/** Marks are made when used, so `--plain` (set after load) is read. */
+const STATE_MARK = {
+	waiting: () => style("dim", "·"),
+	running: () => style("cyan", "●"),
+	ok: () => style("green", "✓"),
+	failed: () => style("red", "✗"),
+	skipped: () => style("dim", "-")
+};
+/** `950`, `12.3k`, `1.2M`. */
+const count = shortCount;
+const stateText = (node) => {
+	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
+	if (node.state === "ok" || node.state === "failed") {
+		const verdict = nodeVerdict(node.output ?? {}, node.state === "ok");
+		const line = verdict.length > 60 ? `${verdict.slice(0, 59)}…` : verdict;
+		return node.runs > 1 ? `${line} (${String(node.runs)} runs)` : line;
+	}
+	return node.state;
+};
+/** A node's counted tokens: input, output and cache write. */
+const countedOf = (node) => node.inputTokens + node.outputTokens + (node.cacheWriteTokens ?? 0);
+/**
+* What a node spent: its counted tokens, then dollars unless its driver reports
+* none, where `$0.00` would be false. Blank with no tokens.
+*/
+const worth = (node) => {
+	const counted = countedOf(node);
+	if (counted === 0) return "";
+	const tok = `${count(counted)} tok`;
+	return style("dim", `  ${node.unpriced === true ? tok : `${tok} · ${cost(node.costUsd)}`}`);
+};
+/**
+* A crashed run's node that never ended: cut off when it had started, not run
+* when it had not; `null` for one that ended.
+*/
+const crashedState = (node) => {
+	if (node.state === "running") return `${STATE_MARK.failed()} cut off`;
+	if (node.state === "waiting") return `${STATE_MARK.skipped()} not run`;
+	return null;
+};
+/**
+* The ownership tree, one line per node, children under their owner. A node in
+* `waits` (a live run's `lockWaitsOf`) reads `waiting for <lock>`, an item too.
+* In a `crashed` run, a node started but not ended reads `cut off` and one not
+* started `not run`: nothing will end them.
+*/
+const formatTree = (roots, now = Date.now(), waits = [], crashed = false) => {
+	const lines = [];
+	const walk = (raw, lead, branch) => {
+		const node = raw.description === void 0 ? raw : {
+			...raw,
+			description: maskSecrets(raw.description)
+		};
+		const named = node.description === void 0 ? "" : `  ${node.description}`;
+		lines.push({
+			label: `${lead}${branch}${node.id}${named}`,
+			node
+		});
+		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
+		node.children.forEach((child, index) => {
+			walk(child, next, index === node.children.length - 1 ? "└─ " : "├─ ");
+		});
+	};
+	for (const root of roots) walk(root, "", "");
+	const label = Math.max(...lines.map((l) => widthOf(l.label)));
+	const type = Math.max(...lines.map((l) => l.node.type.length));
+	return lines.map(({ label: text, node }) => {
+		const usage = worth(node);
+		const lock = waits.find((wait) => wait.id === node.id)?.lock;
+		const cut = crashed ? crashedState(node) : null;
+		const state = cut ?? (node.held === true ? `${style("yellow", "‖")} paused` : lock === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} waiting for ${lock}`);
+		const spent = isItem(node) && node.startedAt !== void 0 && cut === null ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
+		return `${node.description === void 0 ? text : `${text.slice(0, text.length - node.description.length)}${dim(node.description)}`}${" ".repeat(label - widthOf(text))}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
+	});
+};
+/**
+* What `ork tree` prints: the run's header (its status as `ork ps` reads it)
+* and the tree. A finished run's lock waits are stale, so only a live run's
+* show; `events` are the run's, `roots` its nested tree.
+*/
+const formatTreeView = (run, events, roots, now = Date.now()) => {
+	const status = runStatus(run, events);
+	const waits = status === "running" ? lockWaitsOf(events) : [];
+	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}`, ...formatTree(roots, now, waits, status === "crashed")];
+};
+export { header as a, listedStatus as i, formatRuns as n, table as o, formatTreeView as r, ago as t };

package/dist/{help-groups-BwYoAWsh.mjs → help-groups-BpRgBSTh.mjs}

@@ -4,7 +4,9 @@
 *   shell. Each is thin: it runs `ork __complete -- <words…>` with the word
 *   under the cursor last, and offers the lines it prints, `value<TAB>
 *   description`. A line `:group <title>` starts a group (zsh labels the menu
-*   with it); `:files` asks for file names too. A new shell is one more entry.
+*   with it); `:files` asks for file names too. A value ending in `=` (an
+*   input's `name=`) takes no space after it, so its value is typed next. A new
+*   shell is one more entry.
 */
 /** The hidden command the scripts run. */
 const COMPLETE_COMMAND = "__complete";
@@ -15,9 +17,11 @@ const SHELL_SCRIPTS = {
 # (ork completion zsh > ~/.zsh/completions/_ork), or source it.
 
 _ork() {
-  local -a lines cands
+  local -a lines cands opens
   local line group=commands files=0 n=0 ret=1
   lines=("\${(@f)$("\${words[1]}" ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  # A last group line offers what the last group gathered.
+  lines+=(":group end")
   for line in "\${lines[@]}"; do
     case $line in
       (:files) files=1 ;;
@@ -25,15 +29,17 @@ _ork() {
         if (( \${#cands} )); then
           _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
         fi
-        cands=()
+        # name= is followed by its value, not a space.
+        if (( \${#opens} )); then
+          _describe -V -t "ork-$(( ++n ))" "$group" opens -S '' && ret=0
+        fi
+        cands=() opens=()
         group=\${line#:group }
         ;;
+      (*=$'\\t'*) opens+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
       (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
     esac
   done
-  if (( \${#cands} )); then
-    _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
-  fi
   if (( files )); then
     _files && ret=0
   fi
@@ -48,9 +54,10 @@ fi
 `,
 	bash: `# Tab completion for ork, in bash. Add to your ~/.bashrc:
 #   eval "$(ork completion bash)"
-# (macOS's bash 3.2 can't source <(…); saving it to a file and sourcing that
-# works too.) Every expansion is quoted and lines are read with read -r, so a
-# candidate is never split or glob-expanded.
+# (macOS's bash 3.2 loads nothing from source <(…), and prints no error;
+# saving it to a file and sourcing that works in every version.) Every
+# expansion is quoted and lines are read with read -r, so a candidate is never
+# split or glob-expanded.
 
 _ork() {
   local line="\${COMP_LINE:0:COMP_POINT}" cur files=0 strip="" out
@@ -59,10 +66,15 @@ _ork() {
   if [[ "$line" == *[[:space:]] ]]; then words+=(""); fi
   cur="\${words[\${#words[@]}-1]}"
   COMPREPLY=()
-  # bash splits a word at ":" (ork:feature); offer only what follows it.
-  if [[ "$cur" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
-    strip="\${cur%"\${cur##*:}"}"
-  fi
+  # bash splits a word at ":" and "=" (ork:feature, --input=plan=); offer only
+  # what follows the last of them that is a word break.
+  local brk pre
+  for brk in : =; do
+    if [[ "$cur" == *"$brk"* && "$COMP_WORDBREAKS" == *"$brk"* ]]; then
+      pre="\${cur%"\${cur##*"$brk"}"}"
+      if (( \${#pre} > \${#strip} )); then strip="$pre"; fi
+    fi
+  done
   out="$("\${words[0]}" ${COMPLETE_COMMAND} -- "\${words[@]:1}" 2>/dev/null)"
   while IFS= read -r line; do
     case "$line" in
@@ -71,6 +83,10 @@ _ork() {
       *)
         line="\${line%%$'\\t'*}"
         COMPREPLY+=("\${line#"$strip"}")
+        # name= is followed by its value, not a space (bash 4 and later).
+        if [[ "$line" == *= ]] && type compopt &>/dev/null; then
+          compopt -o nospace
+        fi
         ;;
     esac
   done <<< "$out"
@@ -103,68 +119,6 @@ complete -c ork -f -a '(__ork_complete)'
 };
 /** The shells there is a script for. */
 const SHELLS = Object.keys(SHELL_SCRIPTS);
-// src/command-tree.ts
-/** How a flag that only Ork passes to itself starts its description. */
-const INTERNAL = "Internal:";
-/** Whether citty was given a function that gives the value. */
-const isThunk = (value) => typeof value === "function";
-/** A value citty lets be given as is, as a promise, or as a function. */
-const resolved = (value) => Promise.resolve(isThunk(value) ? value() : value);
-/** `args` without the flags only Ork passes to itself. */
-const publicArgs = (args) => Object.fromEntries(Object.entries(args).filter(([, def]) => !(def.description ?? "").startsWith(INTERNAL)));
-/** A command's flags and positionals, which citty lets be given lazily. */
-const argsOf = (cmd) => cmd.args === void 0 ? Promise.resolve({}) : resolved(cmd.args);
-const listOf = (value) => value === void 0 ? [] : [value].flat();
-const flagOf = (name, def) => ({
-	name,
-	description: def.description ?? "",
-	takesValue: def.type === "string" || def.type === "enum",
-	aliases: "alias" in def ? listOf(def.alias) : [],
-	options: def.type === "enum" ? def.options ?? [] : [],
-	negatable: def.type === "boolean" && def.default === true
-});
-/** A command's public flags and positionals, in the order it defines them. */
-const argInfoOf = async (cmd) => {
-	const entries = Object.entries(publicArgs(await argsOf(cmd)));
-	return {
-		flags: entries.filter(([, def]) => def.type !== "positional").map(([name, def]) => flagOf(name, def)),
-		positionals: entries.filter(([, def]) => def.type === "positional").map(([name, def]) => ({
-			name,
-			description: def.description ?? ""
-		}))
-	};
-};
-/**
-* A command's subcommands, in order, loaded ones resolved. A name whose
-* definition is one listed before it (`wt`, `worktrees`'s) is an alias of that
-* one, not an entry of its own.
-*/
-const subcommandsOf = async (cmd) => {
-	const subs = cmd.subCommands === void 0 ? {} : await resolved(cmd.subCommands);
-	const loaded = await Promise.all(Object.entries(subs).map(async ([name, sub]) => {
-		const def = await resolved(sub);
-		return {
-			name,
-			def,
-			meta: def.meta === void 0 ? {} : await resolved(def.meta)
-		};
-	}));
-	const entries = [];
-	for (const { name, def, meta } of loaded) {
-		const same = entries.find((entry) => entry.def === def);
-		if (same === void 0) entries.push({
-			name,
-			aliases: listOf(meta.alias),
-			description: meta.description ?? "",
-			hidden: meta.hidden === true,
-			def
-		});
-		else same.aliases.push(name);
-	}
-	return entries;
-};
-/** The subcommand `name` (or one of its aliases) of `entries`. */
-const findEntry = (entries, name) => entries.find((entry) => entry.name === name || entry.aliases.includes(name));
 // src/help-groups.ts
 const HELP_GROUPS = [
 	{
@@ -220,6 +174,10 @@ const HELP_GROUPS = [
 				name: "logs",
 				short: "Print a run's transcript"
 			},
+			{
+				name: "attach",
+				short: "Follow a run here and answer its questions"
+			},
 			{
 				name: "tree",
 				short: "Show a run's tree, tokens and cost"
@@ -270,6 +228,10 @@ const HELP_GROUPS = [
 				name: "feedback",
 				short: "What got in the way in your runs"
 			},
+			{
+				name: "follow-ups",
+				short: "What shipped changes left for later"
+			},
 			{
 				name: "worktrees",
 				short: "Track and clean up Ork's worktrees"
@@ -316,6 +278,10 @@ const HELP_GROUPS = [
 				name: "send",
 				short: "Write to a session from a tool node's program"
 			},
+			{
+				name: "once",
+				short: "Run a check unless it passed on these files"
+			},
 			{
 				name: "completion",
 				short: "Print a tab-completion script"
@@ -351,4 +317,4 @@ const groupedEntries = (entries) => {
 		entries: other
 	}].filter((group) => group.entries.length > 0);
 };
-export { findEntry as a, subcommandsOf as c, SHELL_SCRIPTS as d, argsOf as i, COMPLETE_COMMAND as l, groupedEntries as n, publicArgs as o, argInfoOf as r, resolved as s, groupOf as t, SHELLS as u };
+export { SHELL_SCRIPTS as a, SHELLS as i, groupedEntries as n, COMPLETE_COMMAND as r, groupOf as t };

package/dist/in-a-run-CbnKjO7t.mjs

@@ -0,0 +1,27 @@
+import { z as storePath } from "./src-8cOPOgrT.mjs";
+import { g as storeGuarded, h as runMarkerIn } from "./src-I_RyKu6_.mjs";
+// src/commands/in-a-run.ts
+/**
+* @file The commands that act as the user refuse a program or an agent in a run
+*   (ADR-047), in the stores that run guards: the store of a nested run under a
+*   temp HOME is not guarded unless an enclosing run lists it. The refusal
+*   names the variable it saw, for someone at their own terminal who inherited
+*   it. It stops accidents; it is not a boundary.
+*/
+const refusal = (why, env, store) => {
+	const marker = runMarkerIn(env);
+	return marker === null || !storeGuarded(env, store) ? null : `${why} ${marker} is set here. If this is your own terminal, it inherited that from a program in a run (a tmux server started by one, say); open a shell without it.`;
+};
+/** Why `ork watch --accept` refuses here, or `null` when it may run. */
+const acceptRefusal = (env = process.env, store = storePath()) => refusal("`ork watch --accept` approves code to run with nobody there, so a program or an agent in a run cannot use it.", env, store);
+/** Why `ork chat` refuses here, or `null` when it may run. */
+const chatRefusal = (env = process.env, store = storePath()) => refusal("`ork chat` speaks as you, so a program or an agent in a run cannot use it. A program writes to a session with `ork send`.", env, store);
+/** Why `ork decide` will not answer here, or `null` when it may. */
+const decideRefusal = (env = process.env, store = storePath()) => refusal("`ork decide` answers as you, so a program or an agent in a run cannot answer with it; `ork decide --list` still shows what is open.", env, store);
+/** Why `ork continue` refuses here, or `null` when it may run. */
+const continueRefusal = (env = process.env, store = storePath()) => refusal("`ork continue` undoes a pause you set, so a program or an agent in a run cannot use it.", env, store);
+/** Whether `ork ui` may print its sign-in link, which acts as the user. */
+const mayShowSignIn = (env = process.env, store = storePath()) => !storeGuarded(env, store);
+/** Why `ork attach` will not answer here, or `null` when it may. */
+const attachRefusal = (env = process.env, store = storePath()) => refusal("`ork attach` answers as you, so a program or an agent in a run cannot use it; `ork logs` still shows the run.", env, store);
+export { decideRefusal as a, continueRefusal as i, attachRefusal as n, mayShowSignIn as o, chatRefusal as r, acceptRefusal as t };

package/dist/install-CWcpX5g4.mjs

@@ -0,0 +1,211 @@
+import { $r as estimateTokens, Gr as placeFor, Qr as LESSON_CAP_TOKENS, Wr as placeFiles, Xr as inside, ei as guardedBase, ni as writePlainFile, ti as plainPathInside, vr as feedbackActions } from "./src-8cOPOgrT.mjs";
+import path from "node:path";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { spawn } from "node:child_process";
+// ../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
+	};
+};
+/**
+* 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);
+	});
+});
+export { placeOf as i, acceptItem as n, lessonPlaceOf as r, runInstall as t };