@rrlab/cli 1.0.0 → 1.0.1-git-908d2c0.0

package/dist/cli.usage.kdl

@@ -1,7 +1,7 @@
 // @generated by @usage-spec/commander from Commander.js metadata
 name rr
 bin rr
-version "1.0.0"
+version "1.0.1-git-908d2c0.0"
 usage "<command...> [options...]"
 flag --usage help="print KDL spec for this CLI (https://kdl.dev)"
 cmd completion help="print shell completion script (usage)" {
@@ -38,7 +38,7 @@ cmd format help="check & fix format errors" {
 	cmd doctor help="check if the underlying tool is working correctly"
 }
 cmd check help="run static checks" {
-	long_help "Runs `rr jsc` and `rr tsc` concurrently in-process. Aggregates their exit codes — non-zero when either subcommand fails."
+	long_help "Runs `rr jsc` then `rr tsc` in-process, each as its own section. Aggregates their exit codes — non-zero when either subcommand fails."
 }
 cmd doctor help="run all plugin doctors" {
 	long_help "Runs the `doctor()` of every configured plugin capability. Each plugin reports ok / not working. The exit code is non-zero if any reports not working."

package/dist/config.d.mts

@@ -1,4 +1,4 @@
-import { u as Plugin } from "./types-DnqiiIxe.mjs";
+import { u as Plugin } from "./types-snfbujDH.mjs";
 
 //#region src/types/config.d.ts
 type UserConfig = {

package/dist/plugin.d.mts

@@ -1,4 +1,4 @@
-import { C as Linter, D as TypeChecker, E as TypeCheckOptions, O as ReleaseService, S as LintOptions, T as StaticCheckerOptions, _ as Doctor, a as InstallFlags, b as FormatOptions, c as PLUGIN_KINDS, d as PluginCapabilities, f as PluginContext, g as UninstallResult, h as UninstallFlags, i as InstallContext, k as ReleaseServiceOptions, l as Packer, m as UninstallContext, n as ClackPromptsSelectOption, o as InstallResult, p as PluginKind, r as FileOp, s as JsonEdit, t as ClackPrompts, u as Plugin, v as DoctorOutput, w as StaticChecker, x as Formatter, y as DoctorResult } from "./types-DnqiiIxe.mjs";
+import { C as StaticChecker, D as ReleaseService, E as TypeChecker, O as ReleaseServiceOptions, S as RunReport, T as TypeCheckOptions, _ as Doctor, a as InstallFlags, b as LintOptions, c as PLUGIN_KINDS, d as PluginCapabilities, f as PluginContext, g as UninstallResult, h as UninstallFlags, i as InstallContext, l as Packer, m as UninstallContext, n as ClackPromptsSelectOption, o as InstallResult, p as PluginKind, r as FileOp, s as JsonEdit, t as ClackPrompts, u as Plugin, v as FormatOptions, w as StaticCheckerOptions, x as Linter, y as Formatter } from "./types-snfbujDH.mjs";
 import { ShellService } from "@vlandoss/clibuddy";
 
 //#region src/plugin/decide-scaffold.d.ts
@@ -42,15 +42,6 @@ type PickPresetOptions<K extends string> = {
 };
 declare function pickPreset<K extends string>(ctx: InstallContext, opts: PickPresetOptions<K>): Promise<K>;
 //#endregion
-//#region ../../node_modules/.pnpm/tinyexec@1.1.2/node_modules/tinyexec/dist/main.d.mts
-//#endregion
-//#region src/main.d.ts
-interface Output {
-  stderr: string;
-  stdout: string;
-  exitCode: number | undefined;
-}
-//#endregion
 //#region src/plugin/tool-service.d.ts
 type ToolServiceOptions = {
   pkg: string;
@@ -66,9 +57,8 @@ type ToolServiceOptions = {
    */
   from: string;
 };
-type ExecOptions = {
+type RunReportOptions = {
   cwd?: string;
-  verbose?: boolean;
 };
 declare class ToolService {
   #private;
@@ -83,8 +73,15 @@ declare class ToolService {
     from
   }: ToolServiceOptions);
   getBinDir(): Promise<string>;
-  exec(args?: string[], options?: ExecOptions): Promise<Output>;
-  doctor(): Promise<DoctorResult>;
+  /**
+   * Runs the tool capturing its output instead of streaming it, and reports the
+   * verdict straight from the exit code — never a guess parsed from the output.
+   * The board needs the capture to attribute each parallel run's output to its
+   * package; the non-zero exit is returned (not thrown) so every task settles
+   * and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
+   */
+  runReport(args?: string[], options?: RunReportOptions): Promise<RunReport>;
+  doctor(): Promise<RunReport>;
 }
 //#endregion
-export { type ClackPrompts, type ClackPromptsSelectOption, type DecideScaffoldOptions, type Doctor, type DoctorOutput, type DoctorResult, type FileOp, type FormatOptions, type Formatter, type InstallContext, type InstallFlags, type InstallResult, type JsonEdit, type LintOptions, type Linter, PLUGIN_KINDS, type Packer, type PickPresetOptions, type Plugin, type PluginCapabilities, type PluginContext, type PluginDefinition, type PluginKind, ReleaseService, type ReleaseServiceOptions, type ScaffoldDecision, type StaticChecker, type StaticCheckerOptions, ToolService, type ToolServiceOptions, type TypeCheckOptions, type TypeChecker, type UninstallContext, type UninstallFlags, type UninstallResult, decideScaffold, definePlugin, pickPreset };
+export { type ClackPrompts, type ClackPromptsSelectOption, type DecideScaffoldOptions, type Doctor, type FileOp, type FormatOptions, type Formatter, type InstallContext, type InstallFlags, type InstallResult, type JsonEdit, type LintOptions, type Linter, PLUGIN_KINDS, type Packer, type PickPresetOptions, type Plugin, type PluginCapabilities, type PluginContext, type PluginDefinition, type PluginKind, ReleaseService, type ReleaseServiceOptions, type RunReport, type ScaffoldDecision, type StaticChecker, type StaticCheckerOptions, ToolService, type ToolServiceOptions, type TypeCheckOptions, type TypeChecker, type UninstallContext, type UninstallFlags, type UninstallResult, decideScaffold, definePlugin, pickPreset };

package/dist/plugin.mjs

@@ -1,4 +1,4 @@
-import { resolvePackageBin } from "@vlandoss/clibuddy";
+import { palette, resolvePackageBin } from "@vlandoss/clibuddy";
 //#region src/plugin/decide-scaffold.ts
 async function decideScaffold(ctx, opts) {
 	const { label, fileExists, patchHint, unattendedExistingAction = "patch" } = opts;
@@ -63,25 +63,41 @@ var ToolService = class {
 			binName: this.#bin
 		});
 	}
-	async exec(args = [], options = {}) {
-		const { cwd, verbose } = options;
-		return (cwd ? this.#shellService.at(cwd) : this.#shellService).run(await this.getBinDir(), args, {
-			display: this.#bin,
-			verbose
-		});
+	/**
+	* Runs the tool capturing its output instead of streaming it, and reports the
+	* verdict straight from the exit code — never a guess parsed from the output.
+	* The board needs the capture to attribute each parallel run's output to its
+	* package; the non-zero exit is returned (not thrown) so every task settles
+	* and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
+	*/
+	async runReport(args = [], options = {}) {
+		const output = await (options.cwd ? this.#shellService.at(options.cwd) : this.#shellService).runCaptured(await this.getBinDir(), args, { throwOnError: false });
+		const header = palette.dim(`$ ${[this.#bin, ...args].join(" ")}`);
+		const body = combine(output.stdout, output.stderr);
+		return {
+			ok: output.exitCode === 0,
+			output: body ? `${header}\n${body}` : header
+		};
 	}
 	async doctor() {
 		const output = await this.#shellService.runCaptured(await this.getBinDir(), ["--help"], { throwOnError: false });
+		const ok = output.exitCode === 0;
+		const command = palette.dim(`$ ${this.#bin} --help`);
+		if (ok) return {
+			ok,
+			output: command
+		};
+		const detail = combine(output.stdout, output.stderr);
 		return {
-			ok: output.exitCode === 0,
-			output: {
-				stdout: output.stdout,
-				stderr: output.stderr,
-				exitCode: output.exitCode
-			}
+			ok,
+			output: detail ? `${command}\n${detail}` : command
 		};
 	}
 };
+/** Joins the non-empty, trimmed streams of a captured run. */
+function combine(stdout, stderr) {
+	return [stdout, stderr].map((stream) => stream?.trim()).filter(Boolean).join("\n");
+}
 //#endregion
 //#region src/plugin/bin-probe.ts
 async function probeBins(services, pluginName) {

package/dist/run.mjs

@@ -1,5 +1,5 @@
-import path from "node:path";
-import { colorize, createPkg, createShellService, cwd, dirnameOf, palette, run, text } from "@vlandoss/clibuddy";
+import path, { basename } from "node:path";
+import { colorize, createPkg, createShellService, cwd, dirnameOf, palette, run, runTaskBoard, text } from "@vlandoss/clibuddy";
 import { generateToStdout } from "@usage-spec/commander";
 import { Argument, Option, createCommand } from "commander";
 import fs from "node:fs";
@@ -137,6 +137,91 @@ async function createContext(binDir) {
 	};
 }
 //#endregion
+//#region src/program/missing-plugin.ts
+const SUGGESTIONS = {
+	lint: [
+		"biome",
+		"oxc",
+		"eslint"
+	],
+	format: ["biome", "oxc"],
+	jsc: ["biome"],
+	tsc: ["ts"],
+	pack: ["tsdown"]
+};
+function missingPluginError(kind) {
+	const aliases = SUGGESTIONS[kind] ?? [];
+	const officialList = aliases.map((a) => `@rrlab/${a}-plugin`).join(", ");
+	const addList = aliases.map((a) => `rr plugins add ${a}`).join(" | ");
+	return /* @__PURE__ */ new Error(`No plugin provides the '${kind}' capability.` + (officialList ? `\n  Install one of: ${officialList}.` : "") + (addList ? `\n  Try: ${addList}.` : ""));
+}
+//#endregion
+//#region src/program/board.ts
+/** `<command> (<tool>)`, deduped to just `<command>` when the tool's binary is the command itself (e.g. `tsc`). */
+function commandTool(command, provider) {
+	return provider.bin === command ? command : `${command} (${provider.ui})`;
+}
+function pkgName(appPkg) {
+	return appPkg.packageJson.name ?? basename(appPkg.dirPath);
+}
+/** The canonical single-target row label, `<command> (<tool>) · <package>`, so every command reads alike. */
+function targetLabel(command, provider, appPkg) {
+	return `${commandTool(command, provider)} ${palette.dim(`· ${pkgName(appPkg)}`)}`;
+}
+/**
+* The canonical fan-out section title, `<command> (<tool>) · <n> <unit>`. The
+* tool is omitted when the fan-out spans several tools (`rr doctor` → `doctor ·
+* 3 tools`), since the rows then carry the per-tool name.
+*/
+function fanoutTitle(command, provider, count, unit) {
+	return `${provider ? commandTool(command, provider) : command} · ${count} ${unit}`;
+}
+/** Bridges a check-family verb (returns a `RunReport`) to a board row, its `output` becoming the flushed detail. */
+function reportTask(label, run) {
+	return {
+		label,
+		async run() {
+			const report = await run();
+			return {
+				ok: report.ok,
+				detail: report.output
+			};
+		}
+	};
+}
+let collector = null;
+async function runCheckSections(run) {
+	const previous = collector;
+	collector = [];
+	try {
+		await run();
+		return collector;
+	} finally {
+		collector = previous;
+	}
+}
+/** Runs the rows on the board and returns whether every row passed. */
+async function runBoard(tasks, options = {}) {
+	const sink = collector;
+	const result = await runTaskBoard(tasks, {
+		...options,
+		frame: options.frame ?? (sink !== null || void 0)
+	});
+	if (sink) sink.push(result);
+	return result;
+}
+/**
+* The shared action body for a single-provider tool command (lint, format, jsc,
+* pack): require the provider, run its verb as one board row labelled
+* `<name> (<tool>) · <pkg>`, and aggregate the exit code. Commands that fan out
+* (tsc) or compose siblings (check) call `runBoard` directly instead.
+*/
+async function runToolCommand(ctx, spec) {
+	const { provider } = spec;
+	if (!provider) throw missingPluginError(spec.kind);
+	if (!(await runBoard([reportTask(targetLabel(spec.name, provider, ctx.appPkg), () => spec.run(provider))])).ok) process.exitCode = 1;
+}
+//#endregion
 //#region src/program/ui.ts
 const CREDITS_TEXT = `\nAcknowledgment:
 - kcd-scripts: for main inspiration
@@ -188,57 +273,56 @@ ${runRunColor(`
 //#endregion
 //#region src/program/commands/check.ts
 /**
-* `rr check` is the umbrella that runs the JS check (lint+format) and the
-* TS type check together. Both subcommands are already wired into
-* commander as siblings (`rr jsc`, `rr tsc`), so we reuse the program's
-* command tree as the action registry instead of duplicating it: look the
-* sibling up by name and invoke its action via `parseAsync([])`, which
-* applies its declared option defaults exactly as if the user had typed
-* `rr jsc` directly.
-*
-* Commander binds the running command as `this` inside an action (see
-* `command.js` — `fn.apply(this, actionArgs)`). `this.parent` gives us the
-* parent program without any late-binding ceremony.
+* `rr check` runs `jsc` then `tsc`. Rather than keep a parallel action
+* registry, it reuses commander's command tree: it finds each sibling on
+* `this.parent` and runs it via `parseAsync([])`, which applies the sibling's
+* own option defaults. (`this` is the running command inside a non-arrow
+* action — see cli/CLAUDE.md.)
 */
 function createCheckCommand(ctx) {
-	return createCommand("check").summary(`run static checks${checkAnnotation(ctx)}`).description("Runs `rr jsc` and `rr tsc` concurrently in-process. Aggregates their exit codes — non-zero when either subcommand fails.").action(async function checkAction() {
+	return createCommand("check").summary(`run static checks${checkAnnotation(ctx)}`).description("Runs `rr jsc` then `rr tsc` in-process, each as its own section. Aggregates their exit codes — non-zero when either subcommand fails.").action(async function checkAction() {
 		const program = this.parent;
 		if (!program) throw new Error("`rr check` requires the parent program to dispatch sibling subcommands.");
-		const cmds = ["jsc", "tsc"].map((name) => ({
-			name,
-			cmd: findCommand(program, name)
-		}));
-		const missing = cmds.filter(({ cmd }) => !cmd).map(({ name }) => name);
-		if (missing.length > 0) {
-			for (const name of missing) logger.error(`rr check: subcommand "${name}" is not registered.`);
-			process.exitCode = 1;
-			return;
-		}
-		const results = await Promise.allSettled(cmds.map(({ cmd }) => cmd.parseAsync([], { from: "user" })));
+		const start = Date.now();
 		const failed = [];
-		for (const [i, r] of results.entries()) if (r.status === "rejected") failed.push({
-			name: cmds[i]?.name ?? "?",
-			reason: r.reason
-		});
-		if (failed.length > 0) {
-			for (const { name, reason } of failed) {
-				const msg = reason instanceof Error ? reason.message : String(reason);
-				logger.error(`rr check (${name}): ${msg}`);
+		let rendered = false;
+		for (const name of ["jsc", "tsc"]) {
+			const cmd = findCommand(program, name);
+			if (!cmd) {
+				logger.error(`rr check: subcommand "${name}" is not registered.`);
+				failed.push(name);
+				continue;
 			}
-			process.exitCode = 1;
+			if (rendered) process.stderr.write("\n");
+			let threw = false;
+			const results = await runCheckSections(async () => {
+				try {
+					await cmd.parseAsync([], { from: "user" });
+				} catch (reason) {
+					logger.error(`rr check (${name}): ${reason instanceof Error ? reason.message : String(reason)}`);
+					threw = true;
+				}
+			});
+			if (threw || results.some((r) => !r.ok)) failed.push(name);
+			rendered = true;
 		}
+		process.stderr.write(`\n${checkVerdict(failed, Date.now() - start)}\n`);
+		if (failed.length > 0) process.exitCode = 1;
 	});
 }
+function checkVerdict(failed, ms) {
+	const elapsed = palette.dim(ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(1)}s`);
+	const sep = palette.dim(" · ");
+	if (failed.length > 0) return `${palette.error("✖")} check failed${sep}${[...new Set(failed)].join(", ")}${sep}${elapsed}`;
+	return `${palette.success("✔")} check passed${sep}${elapsed}`;
+}
 function findCommand(program, name) {
 	return program.commands.find((c) => c.name() === name || c.aliases().includes(name));
 }
 /**
-* Mirrors the provider resolution of `jsc` + `tsc` and flattens the
-* underlying tool labels — e.g. biome (composed lint+format) + oxc (tsc)
-* renders as `(biome, oxlint)` rather than `(biome + biome, oxlint)`. When
-* neither sibling has a provider, falls back to the standard `(not
-* configured)` annotation so the help reads consistently with other
-* commands.
+* Flattens the underlying tool labels of `jsc` + `tsc` for the help summary —
+* e.g. `(biome, oxlint)`, deduped, not `(biome + biome, oxlint)`. Falls back to
+* the standard `(not configured)` when neither sibling has a provider.
 */
 function checkAnnotation(ctx) {
 	const directJsc = ctx.registry.get("jsc");
@@ -322,21 +406,13 @@ const PLUGIN_KINDS = [
 //#region src/program/commands/doctor.ts
 /**
 * Subcommand factory used by every plugin-backed command (lint, format, jsc,
-* tsc, pack) to expose a `doctor` subcommand that verifies the underlying
-* tool is wired correctly. Each calls this with its own provider.
+* tsc, pack) to expose a `doctor` subcommand that verifies the underlying tool
+* is wired correctly. Renders the canonical `doctor (<tool>) · <pkg>` row like
+* every other single-target command — `doctor()` returns a `RunReport`.
 */
-function createDoctorSubcommand(service) {
+function createDoctorSubcommand(service, appPkg) {
 	return createCommand("doctor").summary("check if the underlying tool is working correctly").action(async function doctorAction() {
-		const debug = logger.subdebug("doctor");
-		const { ok, output } = await service.doctor();
-		if (ok) {
-			logger.success(`${service.ui} ok`);
-			debug("%O", output);
-		} else {
-			logger.error(`${service.ui} not working`);
-			debug("%O", output);
-			process.exit(output.exitCode ?? 1);
-		}
+		if (!(await runBoard([reportTask(targetLabel("doctor", service, appPkg), () => service.doctor())])).ok) process.exitCode = 1;
 	});
 }
 /**
@@ -352,23 +428,7 @@ function createDoctorCommand(ctx) {
 			logger.info("No plugins configured. Use `rr plugins add <name>` to install one.");
 			return;
 		}
-		const debug = logger.subdebug("doctor");
-		const results = await Promise.all(services.map(async (svc) => {
-			return {
-				svc,
-				result: await svc.doctor()
-			};
-		}));
-		let failures = 0;
-		for (const { svc, result } of results) if (result.ok) {
-			logger.success(`${svc.ui} ok`);
-			debug("%s: %O", svc.ui, result.output);
-		} else {
-			logger.error(`${svc.ui} not working`);
-			debug("%s: %O", svc.ui, result.output);
-			failures++;
-		}
-		if (failures > 0) process.exitCode = 1;
+		if (!(await runBoard(services.map((svc) => reportTask(svc.ui, () => svc.doctor())), { title: fanoutTitle("doctor", void 0, services.length, "tools") })).ok) process.exitCode = 1;
 	});
 }
 function collectDistinctDoctors(ctx) {
@@ -377,33 +437,18 @@ function collectDistinctDoctors(ctx) {
 	return [...seen];
 }
 //#endregion
-//#region src/program/missing-plugin.ts
-const SUGGESTIONS = {
-	lint: [
-		"biome",
-		"oxc",
-		"eslint"
-	],
-	format: ["biome", "oxc"],
-	jsc: ["biome"],
-	tsc: ["ts"],
-	pack: ["tsdown"]
-};
-function missingPluginError(kind) {
-	const aliases = SUGGESTIONS[kind] ?? [];
-	const officialList = aliases.map((a) => `@rrlab/${a}-plugin`).join(", ");
-	const addList = aliases.map((a) => `rr plugins add ${a}`).join(" | ");
-	return /* @__PURE__ */ new Error(`No plugin provides the '${kind}' capability.` + (officialList ? `\n  Install one of: ${officialList}.` : "") + (addList ? `\n  Try: ${addList}.` : ""));
-}
-//#endregion
 //#region src/program/commands/format.ts
 function createFormatCommand(ctx) {
 	const formatter = ctx.registry.get("format");
 	const cmd = createCommand("format").summary(`check & fix format errors${pluginAnnotation(formatter)}`).description("Checks the code for formatting issues and optionally fixes them, ensuring it adheres to the defined style standards.").option("--fix", "format all the code");
-	if (formatter) cmd.addCommand(createDoctorSubcommand(formatter));
+	if (formatter) cmd.addCommand(createDoctorSubcommand(formatter, ctx.appPkg));
 	cmd.action(async (options = {}) => {
-		if (!formatter) throw missingPluginError("format");
-		await formatter.format(options);
+		await runToolCommand(ctx, {
+			name: "format",
+			kind: "format",
+			provider: formatter,
+			run: (p) => p.format(options)
+		});
 	});
 	if (formatter) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${formatter.ui} CLI to format the code.`);
 	return cmd;
@@ -411,38 +456,51 @@ function createFormatCommand(ctx) {
 //#endregion
 //#region src/program/composed-jsc.ts
 /**
-* Synthesises a `StaticChecker & Doctor` (the `jsc` capability) by composing
-* a separately-registered linter and formatter. Used when the user's plugin
-* set provides `lint` and `format` independently (e.g. oxc, or eslint +
-* prettier) but no single plugin claims `jsc`.
-*
-* The check runs lint then format sequentially — interleaved stdout from a
-* parallel run is hard to read for the user. `fixStaged` is dropped because
-* the underlying tools don't have a uniform staged-aware mode.
+* Synthesises the `jsc` capability (`StaticChecker & Doctor`) by composing a
+* separately-registered linter and formatter — used when the plugin set
+* provides `lint` and `format` independently (e.g. oxc) but no plugin claims
+* `jsc`. Runs lint then format sequentially (parallel stdout interleaves badly)
+* and merges their reports into one board row.
 */
 function composedJscProvider(linter, formatter) {
 	return {
 		bin: `${linter.bin}+${formatter.bin}`,
 		ui: `${linter.ui} + ${formatter.ui}`,
 		async check({ fix }) {
-			await linter.lint({ fix });
-			await formatter.format({ fix });
+			const lintReport = await linter.lint({ fix });
+			const formatReport = await formatter.format({ fix });
+			return mergeReports([{
+				ui: linter.ui,
+				report: lintReport
+			}, {
+				ui: formatter.ui,
+				report: formatReport
+			}]);
 		},
 		async doctor() {
 			const [lintRes, fmtRes] = await Promise.all([linter.doctor(), formatter.doctor()]);
-			const ok = lintRes.ok && fmtRes.ok;
-			const firstFailure = !lintRes.ok ? lintRes : !fmtRes.ok ? fmtRes : void 0;
-			return {
-				ok,
-				output: {
-					stdout: `${linter.ui}:\n${lintRes.output.stdout}\n\n${formatter.ui}:\n${fmtRes.output.stdout}`,
-					stderr: `${linter.ui}:\n${lintRes.output.stderr}\n\n${formatter.ui}:\n${fmtRes.output.stderr}`,
-					exitCode: firstFailure?.output.exitCode ?? 0
-				}
-			};
+			return mergeReports([{
+				ui: linter.ui,
+				report: lintRes
+			}, {
+				ui: formatter.ui,
+				report: fmtRes
+			}]);
 		}
 	};
 }
+/**
+* Folds the lint + format reports into one so the composed `jsc` renders as a
+* single board row: ok only when both passed, with each tool's output kept
+* under its own header so the flushed detail stays attributable.
+*/
+function mergeReports(parts) {
+	const sections = parts.filter((part) => part.report.output.trim()).map((part) => `${part.ui}:\n${part.report.output}`).join("\n\n");
+	return {
+		ok: parts.every((part) => part.report.ok),
+		output: sections
+	};
+}
 //#endregion
 //#region src/program/commands/jscheck.ts
 function createJsCheckCommand(ctx) {
@@ -451,10 +509,14 @@ function createJsCheckCommand(ctx) {
 	const formatter = ctx.registry.get("format");
 	const checker = direct ?? (linter && formatter ? composedJscProvider(linter, formatter) : void 0);
 	const cmd = createCommand("jsc").alias("jscheck").summary(`check format and lint${pluginAnnotation(checker)}`).description("Checks the code for formatting and linting issues, ensuring it adheres to the defined style and quality standards.").option("--fix", "try to fix issues automatically").option("--fix-staged", "try to fix staged files only");
-	if (checker) cmd.addCommand(createDoctorSubcommand(checker));
+	if (checker) cmd.addCommand(createDoctorSubcommand(checker, ctx.appPkg));
 	cmd.action(async (options = {}) => {
-		if (!checker) throw missingPluginError("jsc");
-		await checker.check(options);
+		await runToolCommand(ctx, {
+			name: "jsc",
+			kind: "jsc",
+			provider: checker,
+			run: (p) => p.check(options)
+		});
 	});
 	if (checker) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${checker.ui} CLI to check the code.`);
 	return cmd;
@@ -464,10 +526,14 @@ function createJsCheckCommand(ctx) {
 function createLintCommand(ctx) {
 	const linter = ctx.registry.get("lint");
 	const cmd = createCommand("lint").summary(`check & fix lint errors${pluginAnnotation(linter)}`).description("Checks the code for linting issues and optionally fixes them, ensuring it adheres to the defined quality standards.").option("-c, --check", "check if the code is valid", true).option("--fix", "try to fix all the code");
-	if (linter) cmd.addCommand(createDoctorSubcommand(linter));
+	if (linter) cmd.addCommand(createDoctorSubcommand(linter, ctx.appPkg));
 	cmd.action(async (options = {}) => {
-		if (!linter) throw missingPluginError("lint");
-		await linter.lint(options);
+		await runToolCommand(ctx, {
+			name: "lint",
+			kind: "lint",
+			provider: linter,
+			run: (p) => p.lint(options)
+		});
 	});
 	if (linter) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${linter.ui} CLI to lint the code.`);
 	return cmd;
@@ -478,12 +544,16 @@ function createPackCommand(ctx) {
 	const packer = ctx.registry.get("pack");
 	const cmd = createCommand("pack").summary(`pack a ts library${pluginAnnotation(packer)}`).description("Compiles TypeScript code into JavaScript and generates type declaration files, packaging the library for distribution.");
 	if (packer) {
-		cmd.addCommand(createDoctorSubcommand(packer));
+		cmd.addCommand(createDoctorSubcommand(packer, ctx.appPkg));
 		cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${packer.ui} CLI to pack the project.`);
 	}
 	cmd.action(async () => {
-		if (!packer) throw missingPluginError("pack");
-		await packer.pack();
+		await runToolCommand(ctx, {
+			name: "pack",
+			kind: "pack",
+			provider: packer,
+			run: (p) => p.pack()
+		});
 	});
 	return cmd;
 }
@@ -1143,48 +1213,37 @@ async function pathExists(p) {
 //#endregion
 //#region src/program/commands/tscheck.ts
 const getPreScript = (scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
-async function typecheckAt({ dir, scripts, log, shell, tsc }) {
-	log.debug(`checking types at ${dir}`);
-	const shellAt = cwd === dir ? shell : shell.at(dir);
-	try {
-		const preScript = getPreScript(scripts);
-		if (preScript) {
-			log.start(`Running pre-script: ${preScript}`);
-			await shellAt.run(preScript, [], { shell: true });
-			log.success("Pre-script completed");
-		}
-		log.start("Type checking started");
-		if (cwd === dir) await tsc.check();
-		else await tsc.check({ cwd: dir });
-		log.success("Typecheck completed");
-	} catch (error) {
-		log.error("Typecheck failed");
-		throw error;
-	}
-}
 function createTsCheckCommand(ctx) {
 	const { appPkg, shell } = ctx;
 	const tsc = ctx.registry.get("tsc");
 	const cmd = createCommand("tsc").alias("tscheck").summary(`check typescript errors${pluginAnnotation(tsc)}`).description("Checks the TypeScript code for type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.");
 	if (tsc) {
-		cmd.addCommand(createDoctorSubcommand(tsc));
+		cmd.addCommand(createDoctorSubcommand(tsc, ctx.appPkg));
 		cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${tsc.ui} CLI to check the code.`);
 	}
 	cmd.action(async () => {
 		if (!tsc) throw missingPluginError("tsc");
 		const isTsProject = (dir) => appPkg.hasFile("tsconfig.json", dir);
+		const typecheckTask = (label, dir, scripts) => reportTask(label, async () => {
+			const preScript = getPreScript(scripts);
+			if (preScript) {
+				const pre = await shell.at(dir).runCaptured(preScript, [], {
+					shell: true,
+					throwOnError: false
+				});
+				if ((pre.exitCode ?? 0) !== 0) return {
+					ok: false,
+					output: `pre-script \`${preScript}\` failed\n${[pre.stdout, pre.stderr].map((s) => s?.trim()).filter(Boolean).join("\n")}`
+				};
+			}
+			return tsc.check({ cwd: dir });
+		});
 		if (!appPkg.isMonorepo()) {
 			if (!isTsProject(appPkg.dirPath)) {
 				logger.info("No tsconfig.json found, skipping typecheck");
 				return;
 			}
-			await typecheckAt({
-				shell,
-				tsc,
-				dir: appPkg.dirPath,
-				scripts: appPkg.packageJson.scripts,
-				log: logger
-			});
+			if (!(await runBoard([typecheckTask(targetLabel("tsc", tsc, appPkg), appPkg.dirPath, appPkg.packageJson.scripts)])).ok) process.exitCode = 1;
 			return;
 		}
 		const tsProjects = (await appPkg.getWorkspaceProjects()).filter((project) => isTsProject(project.rootDir));
@@ -1192,16 +1251,7 @@ function createTsCheckCommand(ctx) {
 			logger.warn("No ts projects found in the monorepo, skipping typecheck");
 			return;
 		}
-		await Promise.all(tsProjects.map((p) => typecheckAt({
-			shell,
-			tsc,
-			dir: p.rootDir,
-			scripts: p.manifest.scripts,
-			log: logger.child({
-				tag: p.manifest.name,
-				namespace: "typecheck"
-			})
-		})));
+		if (!(await runBoard(tsProjects.map((p) => typecheckTask(p.manifest.name ?? p.rootDir, p.rootDir, p.manifest.scripts)), { title: fanoutTitle("tsc", tsc, tsProjects.length, "packages") })).ok) process.exitCode = 1;
 	});
 	return cmd;
 }