runset 0.0.0 → 0.0.1

package/dist/index.mjs

@@ -2,9 +2,10 @@
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
+import { WriteStream } from "node:tty";
 import fs from "node:fs";
-import os from "node:os";
 import { inspect, styleText } from "node:util";
+import os from "node:os";
 import cp from "node:child_process";
 //#region src/types.ts
 const EXIT_ACTIONS = /* @__PURE__ */ new Set([
@@ -24,10 +25,13 @@ function isStreamDestination(destination) {
 /** Any failure runset reports itself; `exitCode` is what the CLI exits with. */
 var RunsetError = class extends Error {
 	exitCode;
-	constructor(message, exitCode = 1) {
+	/** What the CLI prints in place of `message`; empty when it already said so. */
+	report;
+	constructor(message, exitCode = 1, report) {
 		super(message);
 		this.name = new.target.name;
 		this.exitCode = exitCode;
+		this.report = report;
 	}
 };
 /** A command line runset cannot read. */
@@ -37,6 +41,109 @@ var ConfigError = class extends RunsetError {};
 /** A command that cannot be resolved. */
 var NormalizeError = class extends RunsetError {};
 //#endregion
+//#region src/utils/terminal.ts
+/**
+* Measuring and wrapping text the way a terminal lays it out: escape sequences
+* take no room, wide characters (CJK, emoji) take two columns.
+*/
+const ESCAPE = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007\u001B]*(?:\u0007|\u001B\\)?|[@-Z\\-_])/g;
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function isTerminal(stream) {
+	return stream.isTTY === true;
+}
+/** The width a terminal stream reports; `undefined` for anything else. */
+function terminalColumns(stream) {
+	const { columns } = stream;
+	return isTerminal(stream) && columns > 0 ? columns : void 0;
+}
+/** `COLUMNS` as a positive integer, or `undefined`. */
+function parseColumns(value) {
+	const columns = Number(value);
+	return Number.isInteger(columns) && columns > 0 ? columns : void 0;
+}
+/** The columns `text` takes on screen. */
+function visibleWidth(text) {
+	let width = 0;
+	for (const { segment } of segmenter.segment(text.replace(ESCAPE, ""))) width += columnWidth(segment, width);
+	return width;
+}
+/**
+* Hard-wraps one line to `width` columns, the way the terminal would have, so
+* each piece can carry a label of its own. A style still open at a break is
+* reset at the end of the piece and re-applied at the start of the next, so a
+* label never inherits it. `offset` is the column the line starts at, for tab
+* stops. A line that moves the cursor — `\r`, or any escape but a color — is
+* left whole: where it lands is not something runset can know.
+*/
+function wrapLine(line, width, offset = 0) {
+	const fits = line.length * 2 <= width && !line.includes("	");
+	if (width < 1 || fits || line.includes("\r")) return [line];
+	const pieces = [];
+	let current = "";
+	let column = 0;
+	let style = [];
+	for (const token of tokenize(line)) {
+		if (token.escape) {
+			if (token.text.startsWith("\x1B[") && !isSgr(token.text)) return [line];
+			current += token.text;
+			style = applySgr(style, token.text);
+			continue;
+		}
+		for (const { segment } of segmenter.segment(token.text)) {
+			let size = columnWidth(segment, offset + column);
+			if (column > 0 && column + size > width) {
+				pieces.push(style.length > 0 ? `${current}\u001B[0m` : current);
+				current = style.join("");
+				column = 0;
+				size = columnWidth(segment, offset);
+			}
+			current += segment;
+			column += size;
+		}
+	}
+	pieces.push(current);
+	return pieces;
+}
+function tokenize(text) {
+	const tokens = [];
+	let last = 0;
+	for (const match of text.matchAll(ESCAPE)) {
+		if (match.index > last) tokens.push({
+			escape: false,
+			text: text.slice(last, match.index)
+		});
+		tokens.push({
+			escape: true,
+			text: match[0]
+		});
+		last = match.index + match[0].length;
+	}
+	if (last < text.length) tokens.push({
+		escape: false,
+		text: text.slice(last)
+	});
+	return tokens;
+}
+/** A color or style (`ESC [ … m`); any other CSI moves the cursor. */
+function isSgr(sequence) {
+	return sequence.startsWith("\x1B[") && sequence.endsWith("m");
+}
+/** The SGR sequences in force after `sequence`; a reset clears them. */
+function applySgr(style, sequence) {
+	if (!isSgr(sequence)) return style;
+	const params = sequence.slice(2, -1);
+	if (params === "" || params === "0") return [];
+	return params.startsWith("0;") ? [sequence] : [...style, sequence];
+}
+/** The columns one grapheme takes when it starts at `column`. */
+function columnWidth(grapheme, column) {
+	if (grapheme === "	") return 8 - column % 8;
+	if (/^[ -~]$/.test(grapheme)) return 1;
+	if (/^[\p{Cc}\p{Cf}\p{Mn}\p{Me}]+$/u.test(grapheme)) return 0;
+	if (/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(grapheme) && /\p{Emoji_Presentation}|\uFE0F/u.test(grapheme)) return 2;
+	return /^[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{20000}-\u{3FFFD}]/u.test(grapheme) ? 2 : 1;
+}
+//#endregion
 //#region src/utils/fs.ts
 const require = createRequire(import.meta.url);
 /** The sync counterpart of `import()`: CJS, JSON, and ESM/TS via `require(esm)`. */
@@ -67,17 +174,19 @@ function readPackageJson(cwd) {
 //#region src/config/loadConfig.ts
 /**
 * Loads `runset.config.*` — the `explicitPath`, or the first one found walking
-* up from `cwd` — and unwraps a default export or a factory function.
+* up from `cwd`, where a `package.json` `runset` section counts as one too —
+* and unwraps a default export or a factory function.
 */
 function loadConfigJs({ argv, cwd, env, explicitPath }) {
-	const filePath = explicitPath === void 0 ? findConfigFile(cwd) : path.resolve(cwd, explicitPath);
-	if (filePath === void 0) return {};
-	if (!fs.existsSync(filePath)) throw new ConfigError(`Config file not found: ${explicitPath}`);
-	return unwrapConfigJs(importSync(filePath), {
+	const context = {
 		argv,
 		cwd,
 		env
-	});
+	};
+	if (explicitPath === void 0) return unwrapConfigJs(findConfigJs(cwd) ?? {}, context);
+	const filePath = path.resolve(cwd, explicitPath);
+	if (!fs.existsSync(filePath)) throw new ConfigError(`Config file not found: ${explicitPath}`);
+	return unwrapConfigJs(importSync(filePath), context);
 }
 function unwrapConfigJs(source, context) {
 	const unwrapped = source.default ?? source;
@@ -93,18 +202,33 @@ function ancestors(dir) {
 		dirs.push(parent);
 	}
 }
-function findConfigFile(cwd) {
-	for (const dir of ancestors(cwd)) for (const extension of [
-		"ts",
-		"js",
-		"mjs",
-		"cjs",
-		"json"
-	]) {
-		const candidate = path.join(dir, `runset.config.${extension}`);
-		if (fs.existsSync(candidate)) return candidate;
+/**
+* The nearest config walking up from `cwd`. Within one directory a
+* `runset.config.*` file wins over the `package.json` `runset` section.
+*/
+function findConfigJs(cwd) {
+	for (const dir of ancestors(cwd)) {
+		for (const extension of [
+			"ts",
+			"js",
+			"mjs",
+			"cjs",
+			"json"
+		]) {
+			const candidate = path.join(dir, `runset.config.${extension}`);
+			if (fs.existsSync(candidate)) return importSync(candidate);
+		}
+		const section = readPackageJsonSection(path.join(dir, "package.json"));
+		if (section !== void 0) return section;
 	}
 }
+function readPackageJsonSection(filePath) {
+	if (!fs.existsSync(filePath)) return;
+	const { runset } = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	if (runset === void 0) return;
+	if (runset === null || typeof runset !== "object" || Array.isArray(runset)) throw new ConfigError(`${filePath}: "runset" must be an object`);
+	return runset;
+}
 //#endregion
 //#region src/utils/string.ts
 function toCamelCase(name) {
@@ -113,6 +237,11 @@ function toCamelCase(name) {
 function toKebabCase(name) {
 	return name.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
 }
+/** `850ms` under a second, `2.1s` from one up. */
+function formatDuration(ms) {
+	const rounded = Math.round(ms);
+	return rounded < 1e3 ? `${rounded}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
 //#endregion
 //#region src/config/winArgv.ts
 /**
@@ -152,6 +281,11 @@ const FLAGS = [
 		short: "s",
 		takesValue: false
 	},
+	{
+		name: "recursive",
+		short: "r",
+		takesValue: false
+	},
 	{
 		name: "jobs",
 		short: "j",
@@ -178,9 +312,15 @@ const FLAGS = [
 		name: "cwd",
 		takesValue: true
 	},
+	{
+		name: "env",
+		short: "e",
+		takesValue: true
+	},
 	{
 		name: "color",
-		takesValue: false
+		negated: "none",
+		takesValue: true
 	},
 	{
 		name: "logLevel",
@@ -207,6 +347,19 @@ const FLAGS = [
 		name: "labels",
 		takesValue: true
 	},
+	{
+		name: "showCommand",
+		takesValue: false
+	},
+	{
+		name: "showExitCode",
+		takesValue: false
+	},
+	{
+		name: "wrap",
+		short: "w",
+		takesValue: false
+	},
 	{
 		name: "help",
 		short: "h",
@@ -234,6 +387,13 @@ function parseCli(rawArgv) {
 	let cursor = 0;
 	function setOption(spec, raw) {
 		switch (spec.name) {
+			case "env": {
+				const text = String(raw);
+				const eq = text.indexOf("=");
+				if (eq < 1) throw new CliError(`Option "--env" takes NAME=value, not "${text}".`);
+				(options.env ??= {})[text.slice(0, eq)] = text.slice(eq + 1);
+				break;
+			}
 			case "help":
 				help = true;
 				break;
@@ -265,8 +425,8 @@ function parseCli(rawArgv) {
 		const flag = findLongFlag(name);
 		if (flag === void 0 && /^no-?[A-Za-z]/.test(name)) {
 			const negated = findLongFlag(name.replace(/^no-?/, ""));
-			if (negated && !negated.takesValue) {
-				setOption(negated, false);
+			if (negated && (!negated.takesValue || negated.negated !== void 0)) {
+				setOption(negated, negated.negated ?? false);
 				return;
 			}
 		}
@@ -359,6 +519,11 @@ function booleanError(name, value) {
 function stringError(name, value) {
 	return typeof value === "string" ? void 0 : `${name} must be a string, got ${formatValue(value)}.`;
 }
+function envError(name, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return `${name} must be an object.`;
+	const bad = Object.entries(value).find(([, entry]) => typeof entry !== "string");
+	return bad === void 0 ? void 0 : `${name}.${bad[0]} must be a string, got ${formatValue(bad[1])}.`;
+}
 function oneOfError(name, value, allowed) {
 	return allowed.has(value) ? void 0 : `${name} is one of ${[...allowed].join(", ")}, got ${formatValue(value)}.`;
 }
@@ -389,12 +554,20 @@ const LABEL_MODES = /* @__PURE__ */ new Set([
 	"custom",
 	"all"
 ]);
+const COLOR_MODES = /* @__PURE__ */ new Set([
+	"auto",
+	"none",
+	"basic",
+	"soft",
+	"all"
+]);
 const KNOWN_KEYS = /* @__PURE__ */ new Set([
 	"color",
 	"commandDictionary",
 	"commands",
 	"cwd",
 	"dryRun",
+	"env",
 	"formatLabel",
 	"jobs",
 	"killTimeout",
@@ -402,9 +575,14 @@ const KNOWN_KEYS = /* @__PURE__ */ new Set([
 	"logLevel",
 	"onFailure",
 	"onSuccess",
+	"output",
 	"parallel",
+	"recursive",
+	"showCommand",
+	"showExitCode",
 	"stderr",
-	"stdout"
+	"stdout",
+	"wrap"
 ]);
 /** Parses, loads and validates; anything left out comes from the process. */
 function createConfig({ cli = parseCli(process.argv.slice(2)), configJs, cwd = process.cwd(), destinations = process, env = process.env } = {}) {
@@ -432,6 +610,12 @@ var Config = class {
 	onFailure;
 	color;
 	parallel;
+	recursive;
+	showCommand;
+	showExitCode;
+	wrap;
+	/** `COLUMNS` as runset was started with it: the width where no TTY says. */
+	envColumns;
 	labels;
 	logLevel;
 	dryRun;
@@ -445,7 +629,6 @@ var Config = class {
 		const { options } = cli;
 		this.cwd = path.resolve(cwd, options.cwd ?? ".");
 		this.destinations = destinations;
-		this.env = env;
 		const context = {
 			argv: cli.argv,
 			cwd: this.cwd,
@@ -457,12 +640,23 @@ var Config = class {
 		}) : unwrapConfigJs(configJs, context);
 		for (const key of Object.keys(file)) if (!KNOWN_KEYS.has(key)) this.warnings.push(`Unknown config key "${key}" was ignored.`);
 		if (file.cwd !== void 0 && options.cwd === void 0) this.cwd = path.resolve(cwd, file.cwd);
+		check(envError("env", file.env ?? {}), ConfigError);
+		this.env = {
+			...env,
+			...file.env,
+			...options.env
+		};
 		this.commands = [...file.commands ?? [], ...cli.commands].filter(Boolean);
 		this.commandDictionary = file.commandDictionary ?? {};
 		this.args = cli.positional;
 		this.jobs = options.jobs ?? file.jobs ?? Number.POSITIVE_INFINITY;
 		this.killTimeout = options.killTimeout ?? file.killTimeout ?? DEFAULT_KILL_TIMEOUT;
 		this.parallel = file.parallel ?? false;
+		this.recursive = options.recursive ?? file.recursive ?? false;
+		this.showCommand = options.showCommand ?? file.showCommand ?? false;
+		this.showExitCode = options.showExitCode ?? file.showExitCode ?? false;
+		this.wrap = options.wrap ?? file.wrap ?? false;
+		this.envColumns = parseColumns(env.COLUMNS);
 		this.labels = options.labels ?? file.labels ?? "auto";
 		this.onSuccess = options.onSuccess ?? file.onSuccess ?? "continue";
 		this.onFailure = options.onFailure ?? file.onFailure ?? "stop";
@@ -470,7 +664,16 @@ var Config = class {
 		this.logLevel = options.logLevel ?? file.logLevel ?? "info";
 		this.color = resolveColor(options.color ?? file.color, env, destinations);
 		this.formatLabel = file.formatLabel;
-		const std = (stream) => mergeStd(mergeStd(defaultStd(stream), file[stream] ?? options.output), options[stream] ?? options.output);
+		const std = (stream) => {
+			let result = defaultStd(stream);
+			for (const value of [
+				file.output,
+				file[stream],
+				options.output,
+				options[stream]
+			]) result = mergeStd(result, value);
+			return result;
+		};
 		this.stdout = std("stdout");
 		this.stderr = std("stderr");
 	}
@@ -480,8 +683,12 @@ var Config = class {
 			oneOfError("logLevel", this.logLevel, LOG_LEVELS),
 			numberError("jobs", this.jobs, 1),
 			numberError("killTimeout", this.killTimeout, 0),
-			booleanError("color", this.color),
+			oneOfError("color", this.color, COLOR_MODES),
 			booleanError("parallel", this.parallel),
+			booleanError("recursive", this.recursive),
+			booleanError("showCommand", this.showCommand),
+			booleanError("showExitCode", this.showExitCode),
+			booleanError("wrap", this.wrap),
 			booleanError("dryRun", this.dryRun),
 			oneOfError("labels", this.labels, LABEL_MODES),
 			stdError("stdout", this.stdout),
@@ -497,17 +704,291 @@ var Config = class {
 		return this.commands.some((command) => typeof command === "object" && command !== null ? !isCommandSettings(command) : Boolean(command));
 	}
 };
-function isTerminal(stream) {
-	return stream.isTTY === true;
+/**
+* A mode as given; under `auto`, whether to color at all, then `soft` where
+* the terminal shows 256 colors. `all` is only ever asked for. Anything else is
+* left for `validate` to refuse.
+*/
+function resolveColor(mode, env, destinations) {
+	if (mode !== void 0 && mode !== "auto") return mode;
+	if (!detectColor(env, destinations)) return "none";
+	return WriteStream.prototype.getColorDepth(env) >= 8 ? "soft" : "basic";
 }
-/** Flag, then `NO_COLOR`/`FORCE_COLOR`, then whether both streams are TTYs. */
-function resolveColor(flag, env, destinations) {
-	if (flag !== void 0) return flag;
+/** `NO_COLOR`/`FORCE_COLOR`, then whether both streams are TTYs. */
+function detectColor(env, destinations) {
 	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
 	if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
 	return isTerminal(destinations.stdout) && isTerminal(destinations.stderr);
 }
 //#endregion
+//#region src/utils/colors.ts
+const KNOWN = new Set(Object.keys(inspect.colors));
+const SHADES = {
+	mint: {
+		index: 115,
+		fallback: "greenBright"
+	},
+	sky: {
+		index: 111,
+		fallback: "blueBright"
+	},
+	rose: {
+		index: 211,
+		fallback: "magentaBright"
+	},
+	amber: {
+		index: 179,
+		fallback: "yellowBright"
+	},
+	lavender: {
+		index: 183,
+		fallback: "magentaBright"
+	},
+	aqua: {
+		index: 80,
+		fallback: "cyanBright"
+	},
+	coral: {
+		index: 210,
+		fallback: "redBright"
+	},
+	sage: {
+		index: 151,
+		fallback: "greenBright"
+	},
+	periwinkle: {
+		index: 147,
+		fallback: "blueBright"
+	},
+	peach: {
+		index: 216,
+		fallback: "yellowBright"
+	},
+	teal: {
+		index: 79,
+		fallback: "cyanBright"
+	},
+	lilac: {
+		index: 177,
+		fallback: "magentaBright"
+	},
+	lime: {
+		index: 149,
+		fallback: "greenBright"
+	},
+	steel: {
+		index: 110,
+		fallback: "blueBright"
+	},
+	pink: {
+		index: 218,
+		fallback: "magentaBright"
+	},
+	seafoam: {
+		index: 121,
+		fallback: "cyanBright"
+	},
+	apricot: {
+		index: 215,
+		fallback: "yellowBright"
+	},
+	mauve: {
+		index: 139,
+		fallback: "magentaBright"
+	},
+	jade: {
+		index: 114,
+		fallback: "greenBright"
+	},
+	sand: {
+		index: 180,
+		fallback: "yellowBright"
+	},
+	iris: {
+		index: 141,
+		fallback: "blueBright"
+	},
+	ice: {
+		index: 117,
+		fallback: "cyanBright"
+	},
+	salmon: {
+		index: 174,
+		fallback: "redBright"
+	},
+	olive: {
+		index: 150,
+		fallback: "greenBright"
+	},
+	navy: {
+		index: 24,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	plum: {
+		index: 96,
+		fallback: "magenta",
+		foreground: "paper"
+	},
+	forest: {
+		index: 22,
+		fallback: "green",
+		foreground: "paper"
+	},
+	wine: {
+		index: 89,
+		fallback: "red",
+		foreground: "paper"
+	},
+	ocean: {
+		index: 25,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	indigo: {
+		index: 61,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	copper: {
+		index: 94,
+		fallback: "red",
+		foreground: "paper"
+	},
+	pine: {
+		index: 23,
+		fallback: "cyan",
+		foreground: "paper"
+	},
+	violet: {
+		index: 55,
+		fallback: "magenta",
+		foreground: "paper"
+	},
+	brick: {
+		index: 88,
+		fallback: "red",
+		foreground: "paper"
+	},
+	slate: {
+		index: 60,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	cocoa: {
+		index: 95,
+		fallback: "red",
+		foreground: "paper"
+	},
+	ink: {
+		index: 235,
+		fallback: "black"
+	},
+	paper: {
+		index: 255,
+		fallback: "whiteBright"
+	}
+};
+/** Every shade by its foreground and its background name, e.g. `mint`, `bgMint`. */
+const SHADE_NAMES = new Map(Object.entries(SHADES).flatMap(([name, custom]) => [[name, custom], [toCamelCase(`bg-${name}`), custom]]));
+const BASIC_PALETTE = [
+	{
+		bgColor: "bgGreen",
+		color: "black"
+	},
+	{
+		bgColor: "bgBlue",
+		color: "white"
+	},
+	{
+		bgColor: "bgMagenta",
+		color: "white"
+	},
+	{
+		bgColor: "bgCyan",
+		color: "black"
+	},
+	{
+		bgColor: "bgYellow",
+		color: "black"
+	},
+	{
+		bgColor: "bgRed",
+		color: "white"
+	},
+	{
+		bgColor: "bgGray",
+		color: "white"
+	},
+	{
+		bgColor: "bgGreenBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgBlueBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgMagentaBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgCyanBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgYellowBright",
+		color: "black"
+	}
+];
+/** Interleave hue families so adjacent assignments remain easy to tell apart. */
+const PALETTE = Object.entries(SHADES).filter(([name]) => name !== "ink" && name !== "paper").map(([name, { foreground }]) => ({
+	bgColor: toCamelCase(`bg-${name}`),
+	color: foreground ?? "ink"
+}));
+/** What `colorLabels` hands out under each mode; `none` still picks, unseen. */
+const PALETTES = {
+	none: BASIC_PALETTE,
+	basic: BASIC_PALETTE,
+	soft: PALETTE.filter((pair) => pair.color === "ink"),
+	all: PALETTE
+};
+/** A built-in style or one of runset's foreground/background shades. */
+function isColorName(name) {
+	return KNOWN.has(name) || shade(name) !== void 0;
+}
+/** Styles text; a shade is painted from the 256-color table. */
+function paint(text, colors) {
+	let result = text;
+	for (const name of colors.toReversed()) {
+		const custom = shade(name);
+		if (custom !== void 0) {
+			const background = name.startsWith("bg");
+			const open = `\u001B[${background ? 48 : 38};5;${custom.index}m`;
+			const close = `\u001B[${background ? 49 : 39}m`;
+			result = open + result.replaceAll(close, open) + close;
+		} else if (KNOWN.has(name)) result = styleText(name, result, { validateStream: false });
+	}
+	return result;
+}
+/** The theme color used for a shade on a basic terminal. */
+function fallbackColor(name) {
+	const custom = shade(name);
+	if (custom === void 0) return name;
+	return name.startsWith("bg") ? toCamelCase(`bg-${custom.fallback}`) : custom.fallback;
+}
+/** A stable palette index for a label. */
+function paletteIndex(label, palette = PALETTE) {
+	/** The largest modulus that keeps `hash * 31 + code` an exact integer. */
+	const HASH_MODULUS = 2147483647;
+	let hash = 0;
+	for (const character of label) hash = (hash * 31 + (character.codePointAt(0) ?? 0)) % HASH_MODULUS;
+	return hash % palette.length;
+}
+function shade(name) {
+	return SHADE_NAMES.get(name);
+}
+//#endregion
 //#region src/plan/stages.ts
 const EMPTY_SEGMENT = {
 	commands: [],
@@ -564,60 +1045,11 @@ function groupByStage(items, stageOf) {
 }
 //#endregion
 //#region src/plan/labels.ts
-const PALETTE = [
-	{
-		bgColor: "bgGreen",
-		color: "black"
-	},
-	{
-		bgColor: "bgBlue",
-		color: "white"
-	},
-	{
-		bgColor: "bgMagenta",
-		color: "white"
-	},
-	{
-		bgColor: "bgCyan",
-		color: "black"
-	},
-	{
-		bgColor: "bgYellow",
-		color: "black"
-	},
-	{
-		bgColor: "bgRed",
-		color: "white"
-	},
-	{
-		bgColor: "bgGray",
-		color: "white"
-	},
-	{
-		bgColor: "bgGreenBright",
-		color: "black"
-	},
-	{
-		bgColor: "bgBlueBright",
-		color: "black"
-	},
-	{
-		bgColor: "bgMagentaBright",
-		color: "black"
-	},
-	{
-		bgColor: "bgCyanBright",
-		color: "black"
-	},
-	{
-		bgColor: "bgYellowBright",
-		color: "black"
-	}
-];
 /**
 * Settles who is labelled, per `config.labels`. Under `auto`, a command
-* sharing a stage is named after itself — or gets a blank label holding the
-* column when someone in its stage has a label of their own.
+* sharing a stage is named after itself, whether or not someone in its stage
+* has a label of their own. Under `custom` it gets a blank label instead,
+* holding the column when someone in its stage has one.
 */
 function assignAutoLabels({ commands, config }) {
 	const mode = config.labels;
@@ -631,7 +1063,7 @@ function assignAutoLabels({ commands, config }) {
 		const labeled = stage.some((command) => command.label !== "");
 		for (const command of stage) {
 			if (command.label !== "") continue;
-			if (mode === "all" || mode === "auto" && shared && !labeled) {
+			if (mode === "all" || mode === "auto" && shared) {
 				command.label = nameOf(command);
 				named.push(command);
 			} else if (shared && labeled) command.label = " ";
@@ -641,16 +1073,23 @@ function assignAutoLabels({ commands, config }) {
 }
 /**
 * Gives each labelled command without colors of its own a palette pair: the
-* one its label hashes to, or the next free when that is taken.
+* one its label hashes to, or the next free when that is taken, from the
+* palette of `config.color`. Without shades every one is first swapped for its
+* theme color, so nothing past the plan has to know how many colors there are.
 */
-function colorLabels({ commands }) {
+function colorLabels({ commands, config }) {
+	const palette = PALETTES[config.color];
+	if (config.color === "none" || config.color === "basic") for (const command of commands) {
+		command.bgColor = fallbackColor(command.bgColor);
+		command.color = fallbackColor(command.color);
+	}
 	const labeled = commands.filter((command) => command.label !== "");
-	const taken = new Set(labeled.map((command) => PALETTE.findIndex((pair) => pair.bgColor === command.bgColor)).filter((index) => index !== -1));
+	const taken = new Set(labeled.map((command) => palette.findIndex((pair) => pair.bgColor === command.bgColor)).filter((index) => index !== -1));
 	for (const command of labeled) {
 		if (command.color !== "" || command.bgColor !== "" || command.label.trim() === "") continue;
-		const index = claim(paletteIndex(command.label), taken);
+		const index = claim(paletteIndex(command.label, palette), taken, palette.length);
 		taken.add(index);
-		const pair = PALETTE[index];
+		const pair = palette[index];
 		command.bgColor = pair.bgColor;
 		command.color = pair.color;
 	}
@@ -661,17 +1100,9 @@ function alignLabels({ commands }) {
 	const width = Math.max(0, ...labeled.map((command) => command.label.length));
 	for (const command of labeled) command.label = command.label.padEnd(width);
 }
-/** A stable palette index for a label. */
-function paletteIndex(label) {
-	/** The largest modulus that keeps `hash * 31 + code` an exact integer. */
-	const HASH_MODULUS = 2147483647;
-	let hash = 0;
-	for (const character of label) hash = (hash * 31 + (character.codePointAt(0) ?? 0)) % HASH_MODULUS;
-	return hash % PALETTE.length;
-}
 /** The script name, or the program a shell command runs. */
 function nameOf(command) {
-	return command.scriptName ?? command.command.split(/\s/, 1)[0] ?? "";
+	return command.packageName ?? command.scriptName ?? command.command.split(/\s/, 1)[0] ?? "";
 }
 /** `serve`, `serve` → `serve#1`, `serve#2`. */
 function numberRepeats(named) {
@@ -685,10 +1116,10 @@ function numberRepeats(named) {
 		command.label = `${command.label}#${index}`;
 	}
 }
-function claim(preferred, taken) {
-	if (taken.size >= PALETTE.length) return preferred;
+function claim(preferred, taken, size) {
+	if (taken.size >= size) return preferred;
 	let index = preferred;
-	while (taken.has(index)) index = (index + 1) % PALETTE.length;
+	while (taken.has(index)) index = (index + 1) % size;
 	return index;
 }
 //#endregion
@@ -719,6 +1150,44 @@ function toRegExp(pattern) {
 	return new RegExp(`^${source.join(":")}$`);
 }
 //#endregion
+//#region src/utils/workspace.ts
+/**
+* The packages of the workspace at or above `cwd`, from `pnpm-workspace.yaml`
+* or `package.json` `workspaces`, sorted by path; the root is not one of them.
+*/
+function readWorkspacePackages(cwd) {
+	for (const dir of ancestors(cwd)) {
+		const patterns = readWorkspacePatterns(dir);
+		if (patterns === void 0) continue;
+		const include = patterns.filter((pattern) => !pattern.startsWith("!"));
+		const exclude = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+		return fs.globSync(include, {
+			cwd: dir,
+			exclude: [...exclude, "**/node_modules"]
+		}).map((match) => path.join(dir, match, "package.json")).filter((filePath) => fs.existsSync(filePath)).toSorted().map((filePath) => readPackageJson(path.dirname(filePath)));
+	}
+	return [];
+}
+function readWorkspacePatterns(dir) {
+	const yamlPath = path.join(dir, "pnpm-workspace.yaml");
+	if (fs.existsSync(yamlPath)) return parsePnpmPackages(fs.readFileSync(yamlPath, "utf8"));
+	const jsonPath = path.join(dir, "package.json");
+	if (!fs.existsSync(jsonPath)) return;
+	const { workspaces } = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
+	return Array.isArray(workspaces) ? workspaces : workspaces?.packages;
+}
+/** The `packages:` list of a `pnpm-workspace.yaml`, read without a YAML parser. */
+function parsePnpmPackages(text) {
+	const patterns = [];
+	let inPackages = false;
+	for (const raw of text.split(/\r?\n/)) {
+		const line = raw.replace(/\s#.*$/, "").trimEnd();
+		if (/^\S/.test(line)) inPackages = /^packages\s*:/.test(line);
+		else if (inPackages && /^\s+-/.test(line)) patterns.push(line.replace(/^\s+-\s*/, "").replaceAll(/^['"]|['"]$/g, ""));
+	}
+	return patterns;
+}
+//#endregion
 //#region src/utils/os.ts
 /** 128 + the signal's number, the way a shell reports it: 130, 143, … */
 function signalExitCode(signal) {
@@ -783,7 +1252,11 @@ function namedValue(key, args) {
 }
 //#endregion
 //#region src/plan/token.ts
-const BOOLEAN_OPTIONS = /* @__PURE__ */ new Set(["disabled", "parallel"]);
+const BOOLEAN_OPTIONS = /* @__PURE__ */ new Set([
+	"disabled",
+	"parallel",
+	"recursive"
+]);
 const ACTION_OPTIONS = /* @__PURE__ */ new Set(["onFailure", "onSuccess"]);
 /** Keys a `::` suffix may set. */
 const INLINE_OPTIONS = /* @__PURE__ */ new Set([
@@ -791,6 +1264,7 @@ const INLINE_OPTIONS = /* @__PURE__ */ new Set([
 	"color",
 	"cwd",
 	"label",
+	"output",
 	"stderr",
 	"stdout",
 	...BOOLEAN_OPTIONS,
@@ -824,7 +1298,7 @@ function parseInlineOptions(text, args) {
 		const written = eq === -1 ? "true" : entry.slice(eq + 1);
 		const value = substitutePlaceholders(key === "label" ? written : written.trim(), args, true);
 		if (!INLINE_OPTIONS.has(key)) throw new NormalizeError(`Unknown command option "${toKebabCase(key)}" in "::${text.trim()}".`);
-		if (key === "stderr" || key === "stdout") options[key] = parsePartialStd(value);
+		if (key === "output" || key === "stderr" || key === "stdout") options[key] = parsePartialStd(value);
 		else if (BOOLEAN_OPTIONS.has(key)) options[key] = value !== "false" && value !== "";
 		else if (ACTION_OPTIONS.has(key)) {
 			check(actionError(`"${toKebabCase(key)}"`, value), NormalizeError);
@@ -847,7 +1321,7 @@ const SETTINGS_OPTIONS = /* @__PURE__ */ new Set([
 */
 function normalize(config, packageInfo) {
 	const scriptNames = Object.keys(packageInfo.scripts);
-	const packageRoot = packageInfo.filePath === "" ? config.cwd : path.dirname(packageInfo.filePath);
+	let workspacePackages;
 	const defaults = {
 		bgColor: "",
 		color: "",
@@ -860,12 +1334,13 @@ function normalize(config, packageInfo) {
 		onFailure: config.onFailure,
 		onSuccess: config.onSuccess,
 		parallel: config.parallel,
+		recursive: config.recursive,
 		stage: 0,
 		stderr: config.stderr,
 		stdout: config.stdout,
 		type: "shell"
 	};
-	function makeLeaf(token, rawOptions, script) {
+	function makeLeaf(token, rawOptions, script, pkg = packageInfo) {
 		const options = {
 			...rawOptions,
 			stderr: mergeStd(defaults.stderr, rawOptions.stderr),
@@ -873,7 +1348,7 @@ function normalize(config, packageInfo) {
 		};
 		const args = substitutePlaceholders(token.args, config.args);
 		const command = [token.name, args].filter((part) => part !== "").join(" ");
-		const line = script === void 0 ? command : [packageInfo.scripts[script], args].filter((part) => part !== "").join(" ");
+		const line = script === void 0 ? command : [pkg.scripts[script], args].filter((part) => part !== "").join(" ");
 		const leaf = {
 			...defaults,
 			...options,
@@ -881,9 +1356,10 @@ function normalize(config, packageInfo) {
 			line,
 			stage: 0,
 			type: script === void 0 ? "shell" : "npm",
-			...script === void 0 ? {} : { scriptName: script }
+			...script === void 0 ? {} : { scriptName: script },
+			...pkg === packageInfo ? {} : { packageName: packageNameOf(pkg) }
 		};
-		if (script !== void 0 && options.cwd === void 0) leaf.cwd = packageRoot;
+		if (script !== void 0 && options.cwd === void 0) leaf.cwd = pkg.filePath === "" ? config.cwd : path.dirname(pkg.filePath);
 		validateCommand(leaf);
 		return leaf;
 	}
@@ -906,6 +1382,14 @@ function normalize(config, packageInfo) {
 			return token.args === "" ? resolved : appendArgs(resolved, token);
 		}
 		const settled = layer(inherited, inline, overrides);
+		if (settled.recursive ?? defaults.recursive) {
+			workspacePackages ??= readWorkspacePackages(config.cwd);
+			const leaves = workspacePackages.flatMap((pkg) => matchScripts(token.name, pkg).map((name) => makeLeaf({
+				...token,
+				name
+			}, settled, name, pkg)));
+			if (leaves.length > 0) return toSegment(leaves, settled);
+		}
 		if (isGlob(token.name)) return toSegment(matchGlob(token.name, scriptNames).map((name) => makeLeaf({
 			...token,
 			name
@@ -969,6 +1453,15 @@ function normalize(config, packageInfo) {
 	commands.sort((first, second) => first.stage - second.stage);
 	return commands;
 }
+/** The scripts of `pkg` a token name matches, glob or not. */
+function matchScripts(name, pkg) {
+	const scriptNames = Object.keys(pkg.scripts);
+	if (isGlob(name)) return matchGlob(name, scriptNames);
+	return Object.hasOwn(pkg.scripts, name) ? [name] : [];
+}
+function packageNameOf(pkg) {
+	return pkg.name || path.basename(path.dirname(pkg.filePath));
+}
 function isSettingsEntry(definition) {
 	return typeof definition === "object" && definition !== null && !Array.isArray(definition) && isCommandSettings(definition);
 }
@@ -998,10 +1491,9 @@ function readSettings(entry, base) {
 /** Layers option bags, later over earlier; stream settings merge per axis. */
 function layer(...bags) {
 	const result = {};
-	for (const { stderr, stdout, ...rest } of bags) {
+	for (const { output, stderr, stdout, ...rest } of bags) {
 		Object.assign(result, rest);
-		if (stdout !== void 0) result.stdout = mergeStd(toPartialStd(result.stdout ?? {}), stdout);
-		if (stderr !== void 0) result.stderr = mergeStd(toPartialStd(result.stderr ?? {}), stderr);
+		for (const [key, own] of [["stderr", stderr], ["stdout", stdout]]) for (const value of [output, own]) if (value !== void 0) result[key] = mergeStd(toPartialStd(result[key] ?? {}), value);
 	}
 	return result;
 }
@@ -1010,7 +1502,11 @@ function validateCommand(command) {
 	const where = (key) => `"${toKebabCase(key)}" on "${command.command}"`;
 	check([
 		...["onFailure", "onSuccess"].map((key) => actionError(where(key), command[key])),
-		...["disabled", "parallel"].map((key) => booleanError(where(key), command[key])),
+		...[
+			"disabled",
+			"parallel",
+			"recursive"
+		].map((key) => booleanError(where(key), command[key])),
 		...[
 			"bgColor",
 			"color",
@@ -1018,7 +1514,7 @@ function validateCommand(command) {
 			"label"
 		].map((key) => stringError(where(key), command[key])),
 		...["stderr", "stdout"].map((key) => stdError(where(key), command[key])),
-		typeof command.env === "object" && command.env !== null ? void 0 : `${where("env")} must be an object.`
+		envError(where("env"), command.env)
 	].find((error) => error !== void 0), NormalizeError);
 }
 //#endregion
@@ -1064,13 +1560,17 @@ function describeOptions(config) {
 		["cwd", config.cwd],
 		["jobs", amount(config.jobs)],
 		["parallel", String(config.parallel)],
+		["recursive", String(config.recursive)],
 		["on-success", config.onSuccess],
 		["on-failure", config.onFailure],
 		["kill-timeout", `${config.killTimeout}ms`],
 		["stdout", describeStd(config.stdout)],
 		["stderr", describeStd(config.stderr)],
 		["labels", config.labels],
-		["color", String(config.color)],
+		["show-command", String(config.showCommand)],
+		["show-exit-code", String(config.showExitCode)],
+		["wrap", String(config.wrap)],
+		["color", config.color],
 		["log-level", config.logLevel]
 	]).map((line) => `  ${line}`)];
 }
@@ -1145,18 +1645,6 @@ function closed(stream) {
 	});
 }
 //#endregion
-//#region src/utils/colors.ts
-const KNOWN = new Set(Object.keys(inspect.colors));
-/** A color name `node:util`'s `styleText` knows. */
-function isColorName(name) {
-	return KNOWN.has(name);
-}
-/** Styles `text` with the known names among `colors`, if any. */
-function paint(text, colors) {
-	const formats = colors.filter((name) => isColorName(name));
-	return formats.length === 0 ? text : styleText(formats, text, { validateStream: false });
-}
-//#endregion
 //#region src/run/Logger.ts
 const RANK = {
 	debug: 3,
@@ -1196,6 +1684,34 @@ var Logger = class {
 	}
 };
 //#endregion
+//#region src/run/prefix.ts
+/**
+* The prefix of a command's output lines: `''` without a label, a function
+* when `formatLabel` may answer differently per line.
+*/
+function makePrefix(command, color, formatLabel, stream) {
+	if (command.label === "") return "";
+	const defaultPrefix = defaultLabel(command, color);
+	if (formatLabel === void 0) return defaultPrefix;
+	return () => String(formatLabel({
+		color,
+		command,
+		defaultPrefix,
+		stream
+	}));
+}
+/** The columns runset's own prefix takes; `0` without a label. */
+function prefixWidth(command, color) {
+	return command.label === "" ? 0 : visibleWidth(defaultLabel(command, color));
+}
+/** A colored block with color; `[label]` without. */
+function defaultLabel(command, color) {
+	if (color && command.label.trim() === "") return `${command.label} `;
+	const formats = [command.bgColor, command.color].filter((name) => isColorName(name));
+	if (!color || formats.length === 0) return `[${command.label}] `;
+	return `${paint(command.label, formats)} `;
+}
+//#endregion
 //#region src/run/env.ts
 /**
 * The environment a command runs in: every `node_modules/.bin` up from `cwd`
@@ -1228,15 +1744,22 @@ var OutputSink = class {
 	/** A prefixed stream's unfinished line, held until its newline. */
 	pending = "";
 	opened;
+	/** Whether everything written so far ended with a newline. */
+	atLineStart = true;
 	std;
 	prefix;
 	destinations;
 	files;
-	constructor(std, prefix, destinations, files) {
+	wrap;
+	/** `COLUMNS`, for a stream that is not a terminal. */
+	envColumns;
+	constructor(std, prefix, destinations, files, wrap = false, envColumns) {
 		this.std = std;
 		this.prefix = prefix;
 		this.destinations = destinations;
 		this.files = files;
+		this.wrap = wrap;
+		this.envColumns = envColumns;
 	}
 	/** Opened on first use, so a command that never writes truncates nothing. */
 	get target() {
@@ -1244,8 +1767,17 @@ var OutputSink = class {
 		this.opened ??= this.files.open(this.std.destination);
 		return this.opened;
 	}
+	/**
+	* The width labelled lines are wrapped to under `wrap`: the terminal's own,
+	* else `COLUMNS`. A file has none, and neither has a run without `wrap`.
+	*/
+	columns() {
+		if (!this.wrap || !isStreamDestination(this.std.destination)) return;
+		return terminalColumns(this.target) ?? this.envColumns;
+	}
 	write(chunk) {
-		if (this.std.destination === "none") return;
+		if (this.std.destination === "none" || chunk === "") return;
+		this.atLineStart = chunk.endsWith("\n");
 		if (this.std.timing === "grouped") {
 			this.buffered += chunk;
 			return;
@@ -1261,6 +1793,10 @@ var OutputSink = class {
 		this.pending = this.pending.slice(end + 1);
 		this.target.write(this.applyPrefix(complete));
 	}
+	/** A line of runset's own, on a line of its own: after any unfinished one. */
+	writeLine(text) {
+		this.write(`${this.atLineStart ? "" : "\n"}${text}\n`);
+	}
 	/** Emits what is held back: a `grouped` stream, or a partial line. */
 	flush() {
 		const held = [this.pending, this.buffered].filter((text) => text !== "");
@@ -1272,34 +1808,19 @@ var OutputSink = class {
 		const { prefix } = this;
 		if (prefix === "") return chunk;
 		const endsWithNewline = chunk.endsWith("\n");
-		return (endsWithNewline ? chunk.slice(0, -1) : chunk).split("\n").map((line) => (typeof prefix === "string" ? prefix : prefix()) + line).join("\n") + (endsWithNewline ? "\n" : "");
+		const body = endsWithNewline ? chunk.slice(0, -1) : chunk;
+		const columns = this.columns();
+		return body.split("\n").map((line) => this.label(line, prefix, columns)).join("\n") + (endsWithNewline ? "\n" : "");
+	}
+	/** One line, prefixed; wrapped first when it would overflow the terminal. */
+	label(line, prefix, columns) {
+		const text = typeof prefix === "string" ? prefix : prefix();
+		if (columns === void 0) return text + line;
+		const width = visibleWidth(text);
+		return wrapLine(line, columns - width, width).map((piece) => text + piece).join("\n");
 	}
 };
 //#endregion
-//#region src/run/prefix.ts
-/**
-* The prefix of a command's output lines: `''` without a label, a function
-* when `formatLabel` may answer differently per line.
-*/
-function makePrefix(command, color, formatLabel, stream) {
-	if (command.label === "") return "";
-	const defaultPrefix = defaultLabel(command, color);
-	if (formatLabel === void 0) return defaultPrefix;
-	return () => String(formatLabel({
-		color,
-		command,
-		defaultPrefix,
-		stream
-	}));
-}
-/** A colored block with color; `[label]` without. */
-function defaultLabel(command, color) {
-	if (color && command.label.trim() === "") return `${command.label} `;
-	const formats = [command.bgColor, command.color].filter((name) => isColorName(name));
-	if (!color || formats.length === 0) return `[${command.label}] `;
-	return `${paint(command.label, formats)} `;
-}
-//#endregion
 //#region src/run/Process.ts
 const USE_PROCESS_GROUPS = process.platform !== "win32";
 /** One command, running in one shell, restarted as its exit policy says. */
@@ -1313,14 +1834,17 @@ var Process = class {
 	finished = false;
 	command;
 	child;
+	/** When the current attempt was spawned, from `performance.now()`. */
+	attemptStart = 0;
 	context;
 	stdout;
 	stderr;
 	constructor(command, context) {
 		this.command = command;
 		this.context = context;
-		const { color, destinations, formatLabel } = context.config;
-		const sink = (stream) => new OutputSink(command[stream], makePrefix(command, color, formatLabel, stream), destinations, context.files);
+		const { destinations, envColumns, formatLabel, wrap } = context.config;
+		const color = context.config.color !== "none";
+		const sink = (stream) => new OutputSink(command[stream], makePrefix(command, color, formatLabel, stream), destinations, context.files, wrap, envColumns);
 		this.stdout = sink("stdout");
 		this.stderr = sink("stderr");
 	}
@@ -1338,10 +1862,15 @@ var Process = class {
 		let stopTheRun = false;
 		for (;;) {
 			this.started = true;
+			if (this.context.config.showCommand) {
+				const run = this.context.config.color === "none" ? "run" : paint("run", ["blue"]);
+				this.stdout.writeLine(`${run} ${this.command.command}`);
+			}
 			await this.spawn();
+			if (this.context.config.showExitCode) this.stdout.writeLine(this.exitLine());
 			this.stdout.flush();
 			this.stderr.flush();
-			this.context.logger.debug(`< ${this.command.line} ${this.report()}`);
+			this.context.logger.debug(`< ${this.command.line} ${this.describeExit()}`);
 			if (this.terminated) break;
 			const action = this.isFailed() ? this.command.onFailure : this.command.onSuccess;
 			if (action !== "restart") {
@@ -1360,14 +1889,45 @@ var Process = class {
 		if (this.child?.pid !== void 0) this.context.logger.debug(`! ${sent} ${this.command.line}`);
 		this.kill(sent);
 	}
-	report() {
-		return this.signal === void 0 ? `exited with ${this.exitCode ?? 0}` : `was killed by ${this.signal}`;
+	/**
+	* `✓ 2.1s` when clean; `– stopped · 2.1s  typecheck` in yellow when runset
+	* stopped it; otherwise `✗ code 1 · 2.1s  typecheck` in red. The command is
+	* in gray, so it can be found without its label.
+	*/
+	exitLine() {
+		const color = this.context.config.color !== "none";
+		const duration = formatDuration(performance.now() - this.attemptStart);
+		if (this.exitCode === 0 && this.signal === void 0 && !this.terminated) return `${color ? paint("✓", ["green"]) : "✓"} ${duration}`;
+		const [status, tint] = this.terminated ? ["– stopped", "yellow"] : [`✗ ${this.shortExit()}`, "red"];
+		const { command } = this.command;
+		return color ? `${paint(status, [tint])} · ${duration}  ${paint(command, ["gray"])}` : `${status} · ${duration}  ${command}`;
+	}
+	/** `code N`, the signal's name, or `stopped`. */
+	shortExit() {
+		if (this.signal !== void 0) return this.signal;
+		return this.exitCode === void 0 ? "stopped" : `code ${this.exitCode}`;
+	}
+	/** `exited with code N`, `was killed by SIGTERM`, or `was stopped`. */
+	describeExit() {
+		if (this.signal !== void 0) return `was killed by ${this.signal}`;
+		return this.exitCode === void 0 ? "was stopped" : `exited with code ${this.exitCode}`;
+	}
+	/**
+	* Under `wrap`, `COLUMNS` narrowed by the label: a child writing to a pipe
+	* has no width of its own, and this is what is left of the parent's for it.
+	*/
+	columnsEnv() {
+		const columns = this.stdout.columns();
+		if (columns === void 0) return {};
+		const width = prefixWidth(this.command, this.context.config.color !== "none");
+		return { COLUMNS: String(Math.max(1, columns - width)) };
 	}
 	/** One attempt: resolves when the child is gone. */
 	async spawn() {
 		const { command, context } = this;
 		this.exitCode = void 0;
 		this.signal = void 0;
+		this.attemptStart = performance.now();
 		context.logger.debug(`> ${command.line}`);
 		await new Promise((resolve) => {
 			let settled = false;
@@ -1377,7 +1937,8 @@ var Process = class {
 				env: createEnv({
 					base: {
 						...context.config.env,
-						...command.env
+						...command.env,
+						...this.columnsEnv()
 					},
 					cwd: command.cwd,
 					packageInfo: context.packageInfo,
@@ -1465,7 +2026,7 @@ var Run = class Run {
 	constructor({ commands, config, packageInfo }) {
 		this.config = config;
 		this.files = new FileRegistry(config.cwd);
-		this.logger = new Logger(config.logLevel, config.destinations.stderr, config.color);
+		this.logger = new Logger(config.logLevel, config.destinations.stderr, config.color !== "none");
 		for (const warning of config.warnings) this.logger.warn(`runset: ${warning}`);
 		const context = {
 			config,
@@ -1517,14 +2078,41 @@ var Run = class Run {
 		const exitCode = failed[0]?.getReportedExitCode();
 		const { stopping } = this;
 		if (this.files.error) throw new RunsetError(this.files.error.message, exitCode ?? 1);
-		if (stopping?.signal) throw new RunsetError(`the run was stopped by ${stopping.signal}`, signalExitCode(stopping.signal));
+		if (stopping?.signal) throw new RunsetError(`the run was stopped by ${stopping.signal}`, signalExitCode(stopping.signal), "");
 		if (stopping?.reason === "terminate") throw new RunsetError("the run was terminated", signalExitCode("SIGTERM"));
-		if (exitCode !== void 0) throw new RunsetError(`${failed.length} command${failed.length === 1 ? "" : "s"} failed: ${failed.map((item) => `"${item.command.command}"`).join(", ")}`, exitCode);
+		if (exitCode !== void 0) throw new RunsetError(`${this.tally()}: ${failed.map((process) => describeFailure(process)).join(", ")}`, exitCode, this.failureReport());
 		return this;
 	}
 	terminate(options = {}) {
 		this.stopEverything({ reason: "terminate" }, options);
 	}
+	/** `1 of 5 commands failed, 2 stopped, 1 not started`. */
+	tally() {
+		const { processes } = this;
+		const total = processes.length;
+		const stopped = processes.filter((process) => process.started && process.terminated).length;
+		const notStarted = processes.filter((process) => !process.started).length;
+		return [
+			`${this.failed().length} of ${total} command${total === 1 ? "" : "s"} failed`,
+			stopped > 0 && `${stopped} stopped`,
+			notStarted > 0 && `${notStarted} not started`
+		].filter(Boolean).join(", ");
+	}
+	/** The tally, then a row per failure, labelled as its output was. */
+	failureReport() {
+		const color = this.config.color !== "none";
+		const red = (text) => color ? paint(text, ["red"]) : text;
+		const rows = this.failed().map((process) => {
+			const { command } = process;
+			const label = command.label.trim();
+			const prefix = makePrefix({
+				...command,
+				label
+			}, color, void 0, "stderr");
+			return `  ${red("✖")} ${prefix}${command.command} ${red(process.describeExit())}`;
+		});
+		return [this.tally(), ...rows].join("\n");
+	}
 	failed() {
 		return this.processes.filter((process) => process.isFailed());
 	}
@@ -1568,6 +2156,12 @@ var Run = class Run {
 		this.stopping.killTimer = void 0;
 	}
 };
+/** `typecheck (api) exited with code 2`; the label only where it adds something. */
+function describeFailure(process) {
+	const { command } = process;
+	const label = command.label.trim();
+	return `${label === "" || label === command.command ? command.command : `${command.command} (${label})`} ${process.describeExit()}`;
+}
 //#endregion
 //#region src/cli.ts
 const HELP = `Usage: runset [options] <command...>
@@ -1578,6 +2172,7 @@ Run mode:
   -p, --parallel <commands>  run the following commands together
   -s, --serial <commands>    run the following commands one after another
   -j, --jobs <n>             max commands running at once (default: unlimited)
+  -r, --recursive            run npm scripts in every workspace package having them
 
 On exit:
       --on-success <action>  what a clean exit does   (default: continue)
@@ -1593,11 +2188,15 @@ Output:
                              destination: stdout | stderr | none | <file path>
       --labels <mode>        label each output line with its command:
                              none | auto | custom | all (default: auto)
+      --show-command         print each command as it starts
+      --show-exit-code       mark each exit and its duration: ✓ 2.1s, ✗ code 1 · 2.1s
+  -w, --wrap                 wrap labelled lines to the terminal, a label on each
 
 General:
   -c, --config <path>        load a config file, skipping the default lookup
       --cwd <dir>            working directory for the commands
-      --color, --no-color    force color on or off
+  -e, --env <NAME=value>     set an environment variable for every command
+      --color <mode>         auto | none | basic | soft | all (default: auto)
       --log-level <level>    error | warn | info | debug (default: info)
       --dry-run              print the resolved stages and run nothing
   -h, --help                 show this help
@@ -1608,12 +2207,14 @@ Command syntax:
                              "npm start::on-failure=restart"
                              "serve --port 80::label=api,color=cyan"
   "build:*"                  glob over package.json script names
+  "build::recursive"         build in every workspace package that has it
   "serve -- --port {1}"      placeholders drawn from arguments after --
 
 Examples:
   runset clean lint "build:**"
   runset -p "watch:**"
   runset clean -p lint test -s deploy
+  runset -e FORCE_COLOR=1 -e 'DEBUG=*' start
 `;
 /** Runs the CLI and returns its exit code. */
 async function main(rawArgv) {
@@ -1636,7 +2237,8 @@ async function main(rawArgv) {
 		return 0;
 	} catch (error) {
 		if (!(error instanceof RunsetError)) throw error;
-		process.stderr.write(`runset: ${error.message}\n`);
+		const report = error.report ?? error.message;
+		if (report !== "") process.stderr.write(`runset: ${report}\n`);
 		return error.exitCode;
 	}
 }