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

package/dist/{brief-DH66xmj8.mjs → brief-C2hew8cS.mjs}

@@ -1,8 +1,9 @@
-import { mr as runGh } from "./src-8cOPOgrT.mjs";
-import { b as takeFollowUps, f as refreshDue, l as briefOf, n as flagValues, p as runIsLive, u as checkTakeable, v as availableDue, y as heldNote } from "./run-DBUAq-Uu.mjs";
-import { n as newRunId } from "./find-BTikxc54.mjs";
-import { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { t as loadWorkflow } from "./validate-BxayjjkV.mjs";
+import { gr as runGh } from "./src-BuF9Lbow.mjs";
+import { a as refreshDue, c as heldNote, l as takeFollowUps, n as checkTakeable, o as runIsLive, s as availableDue, t as briefOf } from "./context-DMK0U1w0.mjs";
+import { n as newRunId } from "./find-Ct5CNl1J.mjs";
+import { l as writeErr } from "./output-DXZbnFt_.mjs";
+import { t as loadWorkflow } from "./validate-_HjACtk9.mjs";
+import { n as flagValues } from "./short-flags-Qf21as0E.mjs";
 // src/follow-ups/brief.ts
 /**
 * @file `ork run --follow-ups <ids>`: the `agent` follow-ups become the run's
@@ -61,7 +62,7 @@ const problemsOf = (loaded, inputs) => {
 * folder, and the run it starts marks them.
 */
 const prepareFollowUps = async (store, rawArgs, runId, target, gh = runGh, mark = true) => {
-	const inputs = flagValues(rawArgs, "--input");
+	const inputs = flagValues(rawArgs, "input");
 	const plain = {
 		inputs,
 		...runId === void 0 ? {} : { runId }

package/dist/{builtin-files-Cf-NZDqM.mjs → builtin-files-YYAnbZGD.mjs}

@@ -1,4 +1,4 @@
-import { Wr as placeFiles, ei as guardedBase, ni as writePlainFile, ti as plainPathInside } from "./src-8cOPOgrT.mjs";
+import { Kr as placeFiles, ii as writePlainFile, ni as guardedBase, ri as plainPathInside } from "./src-BuF9Lbow.mjs";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/{chips-BqcT58qr.mjs → chips-CP_pgKlj.mjs}

@@ -1,4 +1,4 @@
-import { d as CHIP, f as NODE_PALETTE, p as apply } from "./output-B1kwo0YU.mjs";
+import { D as apply, E as NODE_PALETTE, T as CHIP } from "./output-DXZbnFt_.mjs";
 // src/term/chips.ts
 /** The chip words the kit's commands use. */
 const CHIP_LABELS = {
@@ -25,6 +25,11 @@ const statusChip = (status) => {
 		role
 	};
 };
+/**
+* The ASK chip of a question card, in the bright green of the card's bar, so a
+* question reads apart from a run's other chips; `[ASK]` when plain.
+*/
+const askChip = (term) => term.rich ? apply(term, ["bgGreenBright", "black"], ` ${CHIP_LABELS.ask} `) : `[${CHIP_LABELS.ask}]`;
 /** A chip: ` LABEL ` on the role's background; `[LABEL]` when plain. */
 const chip = (term, label, role) => term.rich ? apply(term, CHIP[role], ` ${label} `) : `[${label}]`;
 /** A stable non-negative number for `text` (FNV-1a). */
@@ -40,4 +45,4 @@ const nodeChip = (term, id) => {
 	const format = NODE_PALETTE[nodeSlot(id)] ?? CHIP.muted;
 	return term.rich ? apply(term, format, ` ${id} `) : `[${id}]`;
 };
-export { statusChip as i, chip as n, nodeChip as r, CHIP_LABELS as t };
+export { statusChip as a, nodeChip as i, askChip as n, chip as r, CHIP_LABELS as t };

package/dist/{completion-DS0gCZRm.mjs → completion-K4rAVsrf.mjs}

@@ -1,10 +1,10 @@
-import { Fi as AGENT_DRIVERS, Gr as placeFor, Pn as liveStatus, R as openStore, Wr as placeFiles, st as pendingDecisions, wi as NodeIdSchema, z as storePath } from "./src-8cOPOgrT.mjs";
-import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-Cf-NZDqM.mjs";
-import { t as findRun } from "./find-BTikxc54.mjs";
-import { a as SHELL_SCRIPTS, i as SHELLS, n as groupedEntries, r as COMPLETE_COMMAND, t as groupOf } from "./help-groups-BpRgBSTh.mjs";
+import { Ei as NodeIdSchema, Kr as placeFiles, Pn as liveStatus, R as openStore, Ri as AGENT_DRIVERS, qr as placeFor, st as pendingDecisions, z as storePath } from "./src-BuF9Lbow.mjs";
+import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-YYAnbZGD.mjs";
+import { t as findRun } from "./find-Ct5CNl1J.mjs";
+import { a as SHELL_SCRIPTS, i as SHELLS, n as groupedEntries, r as COMPLETE_COMMAND, t as groupOf } from "./help-groups-BQvcKQ9H.mjs";
 import { o as subcommandsOf, r as findEntry, t as argInfoOf } from "./command-tree-CEkzWNy6.mjs";
-import { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { n as WORKFLOW_SUFFIX, o as resolveWorkflowArg } from "./workflows-DHHi-APg.mjs";
+import { l as writeErr } from "./output-DXZbnFt_.mjs";
+import { n as WORKFLOW_SUFFIX, o as resolveWorkflowArg } from "./workflows-QLjBhGNS.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";

package/dist/{context-CGPh12HV.mjs → context-B-fjPJky.mjs}

@@ -1,7 +1,7 @@
-import { Qr as LESSON_CAP_TOKENS, bt as explainSession } from "./src-8cOPOgrT.mjs";
-import { c as write, s as style } from "./output-B1kwo0YU.mjs";
-import { a as refusedBuiltin, s as workflowArg } from "./workflows-DHHi-APg.mjs";
-import { a as formatReport, t as loadWorkflow } from "./validate-BxayjjkV.mjs";
+import { bt as explainSession, ei as LESSON_CAP_TOKENS } from "./src-BuF9Lbow.mjs";
+import { c as write, s as style } from "./output-DXZbnFt_.mjs";
+import { a as refusedBuiltin, s as workflowArg } from "./workflows-QLjBhGNS.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-_HjACtk9.mjs";
 import { defineCommand } from "citty";
 // src/commands/context.ts
 /**

package/dist/context-DMK0U1w0.mjs

@@ -0,0 +1,160 @@
+import { $n as findFollowUp, Kr as placeFiles, Pn as liveStatus, Sn as deliverFollowUp, Yn as loadProject, gr as runGh, vn as checkFollowUpsDue } from "./src-BuF9Lbow.mjs";
+// ../core/src/follow-ups/take.ts
+const put = (rows, f, run, at) => {
+	const next = {
+		...f,
+		takenBy: run,
+		updatedAt: at
+	};
+	rows.putFollowUp(next);
+	return next;
+};
+/**
+* Why `f` is held by the run that took it, as the end of `taken by run <id>,
+* <note>`; `undefined` when it is free. A run the store does not know counts as
+* live while the mark is recent, so a run that fails its preflight frees its
+* follow-ups when the window ends.
+*/
+const heldNote = (f, isLive, now) => {
+	if (f.takenBy === void 0) return void 0;
+	const live = isLive(f.takenBy);
+	if (live !== void 0) return live ? "still running" : void 0;
+	return now - Date.parse(f.updatedAt) < 12e4 ? "not started yet; free in under 2 minutes" : void 0;
+};
+/** Whether another run holds `f`: it is not free to take again. */
+const heldByLive = (f, run, isLive, now) => f.takenBy !== run && heldNote(f, isLive, now) !== void 0;
+/**
+* The project's due `agent` follow-ups no live run has taken (`ids`), and those
+* a live run holds (`held`), so a second `--follow-ups due` doesn't take them
+* twice.
+*/
+const availableDue = (rows, project, isLive, run = "", now = () => (/* @__PURE__ */ new Date()).toISOString()) => {
+	const at = Date.parse(now());
+	const due = rows.followUps(project).filter((f) => f.for === "agent" && f.status === "due");
+	return {
+		ids: due.filter((f) => !heldByLive(f, run, isLive, at)).map((f) => f.id),
+		held: due.filter((f) => heldByLive(f, run, isLive, at))
+	};
+};
+/**
+* `ork run start --follow-ups <ids>`: the open `agent` follow-ups among `ids`
+* become `run`'s brief; why each other id wasn't taken. One a live run took is
+* refused; one a finished, failed or crashed run took can be taken again.
+*/
+const takeFollowUps = (rows, taking, now = () => (/* @__PURE__ */ new Date()).toISOString()) => {
+	const taken = [];
+	const refused = [];
+	const at = Date.parse(now());
+	for (const id of taking.ids) {
+		const f = rows.followUp(taking.project, id);
+		if (f === void 0) refused.push(`${id}: there is no such follow-up`);
+		else if (f.for !== "agent") refused.push(`${id}: it is for ${f.for}`);
+		else if (f.status === "done" || f.status === "dropped") refused.push(`${id}: it is ${f.status}`);
+		else {
+			const note = f.takenBy === taking.run ? void 0 : heldNote(f, taking.isLive, at);
+			if (note === void 0) taken.push(put(rows, f, taking.run, now()));
+			else refused.push(`${id}: taken by run ${f.takenBy}, ${note}`);
+		}
+	}
+	return {
+		taken,
+		refused
+	};
+};
+// src/follow-ups/context.ts
+/**
+* @file What `ork follow-ups` and a run share: the project's `followUps` rule,
+*   the sink a run hands its sessions' `follow_up` tool, the due check that
+*   runs before every call (a `gh` that fails only warns), and the follow-ups
+*   `ork run --follow-ups` takes as a run's brief.
+*/
+/** The project's `followUps` rule, when it sets one. */
+const followUpsRule = (place) => loadProject(place.root, placeFiles(place).rules).project?.followUps;
+/** What a run hands its sessions: each `follow_up` call, kept as the rule says. */
+const followUpSink = (options) => (input, at) => {
+	const rule = followUpsRule(options.place);
+	return deliverFollowUp(input, {
+		store: options.store,
+		project: options.place.root,
+		worktree: at.cwd,
+		...rule === void 0 ? {} : { rule },
+		...options.home === void 0 ? {} : { home: options.home },
+		...options.gh === void 0 ? {} : { gh: options.gh }
+	});
+};
+/** Gh's own words when it has no login. */
+const SIGNED_OUT = /not logged in|gh auth login/iu;
+/**
+* A gh error's first line, without a trailing period, so the notice is one
+* line.
+*/
+const oneLine = (error) => (error.trim().split("\n")[0] ?? "").trim().replace(/\.$/u, "");
+/**
+* Moves the project's follow-ups whose time has come to due, as every `ork
+* follow-ups` call does first. `gh` failing only warns, through `warn`: one
+* line per call, however many refs failed.
+*/
+const refreshDue = async (store, project, warn, gh = runGh) => {
+	try {
+		const checked = await checkFollowUpsDue({
+			rows: store,
+			project,
+			gh
+		});
+		const [first] = checked.errors;
+		if (first !== void 0) warn(checked.errors.some((error) => SIGNED_OUT.test(error)) ? "Can't check PRs: `gh` isn't signed in. After-merge follow-ups stay waiting; run `gh auth login` yourself." : `Can't check PRs: ${oneLine(first)}. After-merge follow-ups stay waiting.`);
+		return checked.due;
+	} catch (error) {
+		warn(`couldn't check what is due: ${error instanceof Error ? error.message : String(error)}`);
+		return [];
+	}
+};
+/** The text a run starts from when it takes these follow-ups as its brief. */
+const briefOf = (followUps) => ["Do these follow-ups left by earlier changes:", ...followUps.flatMap((f) => [
+	"",
+	`## ${f.title} (${f.id})`,
+	...f.body === "" ? [] : [f.body],
+	...f.where.length === 0 ? [] : [`Files: ${f.where.join(", ")}`]
+])].join("\n");
+/**
+* Whether a run is going, as `ork ps` decides: running with its process alive.
+* `undefined` for a run the store does not know yet: core holds its mark for a
+* short while, as the run may be about to begin.
+*/
+const runIsLive = (store) => (runId) => {
+	const [run] = store.lookup(runId);
+	return run === void 0 ? void 0 : liveStatus(run) === "running";
+};
+const nothing = () => {};
+/**
+* The follow-ups `ids` (or prefixes) name, when every one can be taken as a
+* brief; nothing is written, so a run that fails to start leaves them alone.
+*/
+const checkTakeable = (store, project, ids) => {
+	const full = [];
+	const lines = [];
+	for (const id of ids) {
+		const found = findFollowUp(store, project, id);
+		if (found.ok) full.push(found.followUp.id);
+		else lines.push(found.error);
+	}
+	const { taken, refused } = takeFollowUps({
+		followUp: (p, id) => store.followUp(p, id),
+		followUps: (p) => store.followUps(p),
+		putFollowUp: nothing
+	}, {
+		project,
+		run: "",
+		ids: full,
+		isLive: runIsLive(store)
+	});
+	const all = [...lines, ...refused];
+	return all.length > 0 ? {
+		ok: false,
+		lines: all.map((line) => `--follow-ups: ${line}`)
+	} : {
+		ok: true,
+		followUps: taken
+	};
+};
+export { refreshDue as a, heldNote as c, followUpsRule as i, takeFollowUps as l, checkTakeable as n, runIsLive as o, followUpSink as r, availableDue as s, briefOf as t };

package/dist/{detached-Dakw5RZj.mjs → detached-q0AYG0Bs.mjs}

@@ -1,6 +1,7 @@
-import { pt as detachRun } from "./src-8cOPOgrT.mjs";
-import { n as newRunId } from "./find-BTikxc54.mjs";
-import { c as write, i as detachHint, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { pt as detachRun } from "./src-BuF9Lbow.mjs";
+import { n as newRunId } from "./find-Ct5CNl1J.mjs";
+import { c as write, i as detachHint, l as writeErr, s as style } from "./output-DXZbnFt_.mjs";
+import { r as isFlag } from "./short-flags-Qf21as0E.mjs";
 // src/run/detached.ts
 /**
 * @file `ork run --detach`: checks what the run would refuse (a `--follow-ups`
@@ -10,7 +11,7 @@ import { c as write, i as detachHint, l as writeErr, s as style } from "./output
 /** Starts the run in the background; `rawArgs` are `ork run`'s own, as typed. */
 const startDetached = async (store, options) => {
 	const { rawArgs, cwd, target } = options;
-	const { prepareFollowUps } = await import("./brief-DH66xmj8.mjs");
+	const { prepareFollowUps } = await import("./brief-C2hew8cS.mjs");
 	if (await prepareFollowUps(store, rawArgs, void 0, target, void 0, false) === void 0) return;
 	const single = options.node !== void 0 && options.node !== "";
 	const runId = newRunId(store, single ? "node-" : "");
@@ -19,7 +20,7 @@ const startDetached = async (store, options) => {
 		runId,
 		args: [
 			"run",
-			...rawArgs.filter((arg) => arg !== "--detach"),
+			...rawArgs.filter((arg) => !isFlag(arg, "detach")),
 			"--run-id",
 			runId
 		],

package/dist/{find-BTikxc54.mjs → find-Ct5CNl1J.mjs}

@@ -1,4 +1,4 @@
-import { Gr as placeFor } from "./src-8cOPOgrT.mjs";
+import { qr as placeFor } from "./src-BuF9Lbow.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**

package/dist/{flags-C8yCq0j5.mjs → flags-C90N4J1i.mjs}

@@ -1,8 +1,8 @@
-import { Gr as placeFor } from "./src-8cOPOgrT.mjs";
+import { qr as placeFor } from "./src-BuF9Lbow.mjs";
 import { i as parseLimit, n as unknownProjectRefusal, r as parseFilters, t as limitRefusal } from "./refusals-DQQX3AIb.mjs";
-import { t as findRun } from "./find-BTikxc54.mjs";
+import { t as findRun } from "./find-Ct5CNl1J.mjs";
 import { a as resolved, n as argsOf } from "./command-tree-CEkzWNy6.mjs";
-import { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { l as writeErr } from "./output-DXZbnFt_.mjs";
 import { t as argumentError } from "./argument-error-CihH46Le.mjs";
 // src/list/known-flags.ts
 /** Names citty reads without the command declaring them. */

package/dist/{follow-ups-CtlhHbwe.mjs → follow-ups-D3HPyNYM.mjs}

@@ -1,13 +1,14 @@
-import { $n as isGithubIssueUrl, Cn as followUpProblem, Gr as placeFor, Kt as followUpListTable, Qn as followUpActions, Sn as deliverFollowUp, Yn as changeFollowUp, Zn as findFollowUp, _n as postFollowUpMessage, bn as recordPublished, mr as runGh, yn as markDue } from "./src-8cOPOgrT.mjs";
-import { d as followUpsRule, f as refreshDue, n as flagValues } from "./run-DBUAq-Uu.mjs";
+import { $n as findFollowUp, Cn as followUpProblem, Kt as followUpListTable, Sn as deliverFollowUp, Zn as changeFollowUp, _n as postFollowUpMessage, bn as recordPublished, er as followUpActions, gr as runGh, qr as placeFor, tr as isGithubIssueUrl, yn as markDue } from "./src-BuF9Lbow.mjs";
+import { a as refreshDue, i as followUpsRule } from "./context-DMK0U1w0.mjs";
 import { t as applyFilters } from "./apply-Mb0fNpCX.mjs";
 import { n as unknownProjectRefusal } from "./refusals-DQQX3AIb.mjs";
-import { t as findRun } from "./find-BTikxc54.mjs";
-import { a as plain, c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { t as findRun } from "./find-Ct5CNl1J.mjs";
+import { a as plain, c as write, l as writeErr, s as style } from "./output-DXZbnFt_.mjs";
+import { n as flagValues } from "./short-flags-Qf21as0E.mjs";
 import { t as refuseExtraArguments } from "./extra-arguments-BxQMXARO.mjs";
-import { c as refuseUnknownFlags, i as readListArgs, n as filterArgs } from "./flags-C8yCq0j5.mjs";
-import { t as printList } from "./print-DNYzq4Rr.mjs";
-import { t as withStore } from "./store-CDpk8Wtz.mjs";
+import { c as refuseUnknownFlags, i as readListArgs, n as filterArgs } from "./flags-C90N4J1i.mjs";
+import { t as printList } from "./print-DzugGZQB.mjs";
+import { t as withStore } from "./store-rTgRu8xy.mjs";
 import { homedir } from "node:os";
 import { defineCommand } from "citty";
 // src/follow-ups/command.ts
@@ -253,6 +254,10 @@ const due = defineCommand({
 		const waiting = eachTarget(args._, (target) => {
 			const one = findFollowUp(store, place.root, target);
 			const run = findRun(store, target, "");
+			if (!one.ok && !run.ok) return {
+				ok: false,
+				error: one.error
+			};
 			const runId = run.ok ? run.run.id : target;
 			const ready = (one.ok ? [one.followUp] : store.followUps(place.root).filter((f) => f.from.run === runId)).filter((f) => f.status === "waiting");
 			return ready.length === 0 ? {
@@ -441,13 +446,13 @@ const add = defineCommand({
 			fail("--channel github needs --to <the issue or pull request URL>, https://github.com/<owner>/<repo>/(issues|pull)/<n>.");
 			return;
 		}
-		const steps = flagValues(rawArgs, "--step").map((raw) => stepOf(raw));
+		const steps = flagValues(rawArgs, "step").map((raw) => stepOf(raw));
 		const input = {
 			title: args.title,
 			for: recipient,
 			kind,
 			due,
-			where: flagValues(rawArgs, "--where"),
+			where: flagValues(rawArgs, "where"),
 			...args.body === void 0 ? {} : { body: args.body },
 			...args.ref === void 0 ? {} : { ref: args.ref },
 			...args.text === void 0 ? {} : { draft: {

package/dist/{format-BB4E-T6x.mjs → format-CiPhQqbX.mjs}

@@ -1,7 +1,7 @@
-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";
+import { Fn as lockWaitsOf, Ln as runStatus, Nt as lockWaitLine, Pn as liveStatus, Rn as slotWaitingOf, Vn as yoloOf, Wn as isItem, jr as maskSecrets, zn as slotWaitsOf, zt as slotWaitLine } from "./src-BuF9Lbow.mjs";
+import { n as cost, o as shortCount, r as costOf, s as style, v as termOf, x as widthOf, y as cut } from "./output-DXZbnFt_.mjs";
+import { a as statusChip, r as chip } from "./chips-CP_pgKlj.mjs";
+import { n as nodeVerdict } from "./verdict-B592j1W3.mjs";
 // src/term/table.ts
 /**
 * @file Aligned columns for the listing commands: each column as wide as its
@@ -101,14 +101,15 @@ const listedStatus = (run, events) => {
 * 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)) => {
+const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus, term = termOf(process.stdout), yolo = () => false) => {
 	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,
+			workflow: yolo(run) ? `${run.workflow} · yolo` : run.workflow,
+			yolo: yolo(run),
 			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}`,
@@ -122,7 +123,10 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus,
 				text: r.id,
 				look: (s) => style("bold", s)
 			},
-			{ text: r.workflow },
+			r.yolo ? {
+				text: r.workflow,
+				look: (s) => style("yellow", s)
+			} : { text: r.workflow },
 			{
 				text: r.status,
 				chip: statusChip(r.status),
@@ -203,8 +207,8 @@ const crashedState = (node) => {
 };
 /**
 * 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
+* `waits` (a live run's lock and slot waits) reads its line, 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) => {
@@ -229,9 +233,9 @@ const formatTree = (roots, now = Date.now(), waits = [], crashed = false) => {
 	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 wait = waits.find((each) => each.id === node.id)?.line;
 		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 state = cut ?? (node.held === true ? `${style("yellow", "‖")} paused` : wait === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} ${wait}`);
 		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}`;
 	});
@@ -243,7 +247,14 @@ const formatTree = (roots, now = Date.now(), waits = [], crashed = false) => {
 */
 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")];
+	const waits = status === "running" ? [...lockWaitsOf(events).map(({ id, lock }) => ({
+		id,
+		line: `waiting for ${lock}`
+	})), ...slotWaitingOf(events).map(({ id, holders }) => ({
+		id,
+		line: slotWaitLine(holders)
+	}))] : [];
+	const yolo = status === "running" && yoloOf(events) ? style("yellow", " · yolo") : "";
+	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}${yolo}`, ...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-BpRgBSTh.mjs → help-groups-BQvcKQ9H.mjs}

@@ -18,7 +18,7 @@ const SHELL_SCRIPTS = {
 
 _ork() {
   local -a lines cands opens
-  local line group=commands files=0 n=0 ret=1
+  local line value said 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")
@@ -36,8 +36,13 @@ _ork() {
         cands=() opens=()
         group=\${line#:group }
         ;;
-      (*=$'\\t'*) opens+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
-      (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
+      (?*)
+        value=\${\${line%%$'\\t'*}//:/\\\\:}
+        said=\${line#*$'\\t'}
+        # No description: the value alone, or zsh shows an empty one as --.
+        [[ $said == "$line" || -z $said ]] || value+=":$said"
+        if [[ $line == *=$'\\t'* ]]; then opens+=("$value"); else cands+=("$value"); fi
+        ;;
     esac
   done
   if (( files )); then

package/dist/{in-a-run-CbnKjO7t.mjs → in-a-run-D_wg4iJi.mjs}

@@ -1,5 +1,5 @@
-import { z as storePath } from "./src-8cOPOgrT.mjs";
-import { g as storeGuarded, h as runMarkerIn } from "./src-I_RyKu6_.mjs";
+import { z as storePath } from "./src-BuF9Lbow.mjs";
+import { g as storeGuarded, h as runMarkerIn } from "./src-k0A_QpST.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{install-CWcpX5g4.mjs → install-Hji6LIei.mjs}

@@ -1,4 +1,4 @@
-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 { Kr as placeFiles, Qr as inside, br as feedbackActions, ei as LESSON_CAP_TOKENS, ii as writePlainFile, ni as guardedBase, qr as placeFor, ri as plainPathInside, ti as estimateTokens } from "./src-BuF9Lbow.mjs";
 import path from "node:path";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -181,6 +181,54 @@ const lessonPlaceOf = (store, item, workflow, registered) => {
 		exists
 	};
 };
+// ../core/src/remote/session.ts
+const chattable = (type) => type === "agent.leader" || type === "agent.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.model !== "") session.model = inner.model;
+		}
+		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
+	}
+	return {
+		session,
+		outputs
+	};
+};
 /**
 * Runs the command; resolves its exit code. Without `onOutput` it writes on the
 * terminal.
@@ -208,4 +256,4 @@ const runInstall = (argv, onOutput) => new Promise((resolve) => {
 		resolve(code ?? 1);
 	});
 });
-export { placeOf as i, acceptItem as n, lessonPlaceOf as r, runInstall as t };
+export { placeOf as a, lessonPlaceOf as i, nodeSession as n, acceptItem as r, runInstall as t };

package/dist/{limits-VQqsBoQk.mjs → limits-BD6RZRCS.mjs}

@@ -1,4 +1,4 @@
-import { _t as limitsReport, gt as limitsNow, ht as NOT_STARTED, v as capsHere } from "./src-8cOPOgrT.mjs";
+import { _t as limitsReport, gt as limitsNow, ht as NOT_STARTED, v as capsHere } from "./src-BuF9Lbow.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/{mcp-wGfkMCVF.mjs → mcp-CpbDmBLG.mjs}

@@ -1,8 +1,8 @@
-import { T as isNewer } from "./src-8cOPOgrT.mjs";
-import { h as runMarkerIn } from "./src-I_RyKu6_.mjs";
-import { n as ORK_VERSION } from "./__build_info__-D6mXC4cD.mjs";
-import { n as explainNode } from "./context-CGPh12HV.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CmEvHdju.mjs";
+import { T as isNewer } from "./src-BuF9Lbow.mjs";
+import { h as runMarkerIn } from "./src-k0A_QpST.mjs";
+import { n as ORK_VERSION } from "./__build_info__-0wqQ-rtf.mjs";
+import { n as explainNode } from "./context-B-fjPJky.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-BrFfDKux.mjs";
 import { z } from "zod";
 import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.20") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.21") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/{once-BHxSdZz_.mjs → once-J8Qn5fTG.mjs}

@@ -1,7 +1,7 @@
-import "./src-8cOPOgrT.mjs";
-import { n as OncePathspecError, t as runOnce } from "./run-Bvvg-fiF.mjs";
-import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { t as ago } from "./format-BB4E-T6x.mjs";
+import "./src-BuF9Lbow.mjs";
+import { n as OncePathspecError, t as runOnce } from "./run-CtuNY3mE.mjs";
+import { c as write, l as writeErr, s as style } from "./output-DXZbnFt_.mjs";
+import { t as ago } from "./format-CiPhQqbX.mjs";
 import { spawn } from "node:child_process";
 import { defineCommand, parseArgs } from "citty";
 // src/commands/once.ts