@rrlab/cli 0.0.4-git-9887d65.0 → 1.0.1-git-e008b4d.0

package/dist/cli.usage.kdl

@@ -1,7 +1,7 @@
 // @generated by @usage-spec/commander from Commander.js metadata
 name rr
 bin rr
-version "0.0.4-git-9887d65.0"
+version "1.0.1-git-e008b4d.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-6gZWuLJf.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-6gZWuLJf.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,101 @@ 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 one canonical row label for a single-target run: `<command> (<tool>) · <package>`.
+* Every command/subcommand that acts on one target (lint, format, jsc, pack,
+* single-app tsc, a `doctor` subcommand) builds its row through here so they
+* all read identically.
+*/
+function targetLabel(command, provider, appPkg) {
+	return `${commandTool(command, provider)} ${palette.dim(`· ${pkgName(appPkg)}`)}`;
+}
+/**
+* The one canonical section title for a fan-out run: `<command> (<tool>) · <n> <unit>`
+* (e.g. `tsc (oxlint) · 8 packages`). The tool is omitted when the fan-out
+* spans several tools (`rr doctor` → `doctor · 3 tools`); the rows then carry
+* the per-unit name.
+*/
+function fanoutTitle(command, provider, count, unit) {
+	return `${provider ? commandTool(command, provider) : command} · ${count} ${unit}`;
+}
+/**
+* Bridges a check-family verb (which returns a `RunReport`) to a board row.
+* The row's spinner reflects the in-flight run; the captured `output` becomes
+* the detail the board flushes grouped under the label.
+*/
+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
@@ -201,34 +296,42 @@ ${runRunColor(`
 * parent program without any late-binding ceremony.
 */
 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));
 }
@@ -322,21 +425,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 +447,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 +456,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;
@@ -417,7 +481,8 @@ function createFormatCommand(ctx) {
 * 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
+* parallel run is hard to read for the user — and merges their reports into one
+* so the board renders the pair as a single row. `fixStaged` is dropped because
 * the underlying tools don't have a uniform staged-aware mode.
 */
 function composedJscProvider(linter, formatter) {
@@ -425,24 +490,40 @@ function composedJscProvider(linter, formatter) {
 		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 +532,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 +549,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 +567,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 +1236,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 +1274,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;
 }