@savvy-web/cli 3.5.0 → 3.6.0

package/cli/index.js

@@ -5,7 +5,8 @@ import { initCommand } from "../commands/init.js";
 import { lintCommand } from "../commands/lint/index.js";
 import { reposCommand } from "../commands/repos/index.js";
 import { cleanCommand } from "../commands/clean.js";
-import { Command } from "effect/cli";
+import { CliConfig, Command, GlobalFlag } from "effect/cli";
+import { CliAudience } from "@effected/cli";
 import { BiomeSchemaSync, ChangesetConfigReader, Changesets, ConfigDiscovery, Repos, SilkPublishability } from "@savvy-web/silk-effects";
 import { Layer } from "effect";
 import { Git } from "@effected/git";
@@ -63,7 +64,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 /**
 * Root `savvy` command nesting the two orchestrators and three command groups.
 */
-const rootCommand = Command.make("savvy").pipe(Command.withSubcommands([
+const rootCommand = Command.make("savvy").pipe(Command.withSharedFlags(CliAudience.flags()), Command.withSubcommands([
 	initCommand,
 	checkCommand,
 	cleanCommand,
@@ -128,9 +129,24 @@ const ToolDiscoveryGroupLive = ToolDiscovery.layer.pipe(Layer.provide(LocalExecL
 * provided once, at the edge; this module never runs anything itself.
 */
 const AppLive = Layer.mergeAll(ToolDiscoveryGroupLive, InspectorAndAnalyzerLive, ReposGroupLive).pipe(Layer.provideMerge(BaseLive));
+/**
+* Core's built-in global flags for the whole program: `--help`, `--version`,
+* `--completions` and `--log-level`. Core's generic `--wizard` is trimmed —
+* savvy asks its own questions through `@effected/cli/ui` screens. Provided
+* around the program by `main()`, inside `CliRuntime.main`'s environment, so
+* help, parsing and `CliAudience`'s interactive `--wizard` restore all read
+* it (the kit only restores a wizard its own gate removed, never one a
+* consumer's `builtIns` left out).
+*/
+const CliConfigLive = CliConfig.layer({ builtIns: [
+	GlobalFlag.Help,
+	GlobalFlag.Version,
+	GlobalFlag.Completions,
+	GlobalFlag.LogLevel
+] });
 /** The platform `main()` passes to `CliRuntime.main`: Node's filesystem, path, stdio, terminal and spawner. */
 const CliPlatform = NodeServices.layer;
 /* v8 ignore stop */
 
 //#endregion
-export { AppLive, CliPlatform, rootCommand };
+export { AppLive, CliConfigLive, CliPlatform, rootCommand };

package/commands/changeset/commands/check.js

@@ -1,7 +1,7 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { Argument, Command } from "effect/cli";
-import { resolve } from "node:path";
-import { CliExit } from "@effected/cli";
+import { isAbsolute, relative, resolve } from "node:path";
+import { CliExit, Doc } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 
@@ -16,8 +16,10 @@ import { Effect } from "effect";
 * @remarks
 * The command resolves the directory argument, delegates to
 * {@link ChangesetLinter.validate}, groups the resulting
-* {@link LintMessage} objects by file path, and logs each file's errors
-* indented under the file name. Sets exit code 1 through `CliExit.set` when errors
+* {@link LintMessage} objects by file path, and prints one section per file
+* (titled by the file, its findings as a position/rule/message table) plus a
+* GitHub Actions error annotation per finding, which only the Actions log
+* renders. Sets exit code 1 through `CliExit.set` when errors
 * are found.
 *
 * @example
@@ -28,20 +30,44 @@ import { Effect } from "effect";
 * @internal
 */
 const { ChangesetLinter } = Changesets;
+/** The title `savvy check` gives this section. */
+const SECTION_TITLE = "changesets";
+/** The columns of a file's findings table. */
+const FINDING_COLUMNS = [
+	{ header: "position" },
+	{ header: "rule" },
+	{ header: "message" }
+];
+/**
+* A finding's file as the report and the runner show it: relative to the
+* working directory when it lies under it (what a GitHub Actions annotation
+* resolves against the workspace), absolute otherwise.
+*/
+const displayPath = (cwd, file) => {
+	const rel = relative(cwd, file);
+	return rel === "" || rel.startsWith("..") || isAbsolute(rel) ? file : rel;
+};
 /* v8 ignore next */
 const dirArg = Argument.Directory("dir").pipe(Argument.withDefault(".changeset"));
 /**
-* Run the check validation pipeline on all changeset files in `dir`.
+* The changeset check as a {@link CheckSection}: its blocks and verdict,
+* unprinted, for `savvy check` to fold into its one document.
 *
-* Groups lint messages by file and logs a human-readable summary. Sets
-* exit code 1 through `CliExit.set` when one or more errors are found.
+* @remarks
+* One titled section per file with errors (its findings as a
+* position/rule/message table), each followed by one GitHub Actions error
+* annotation per finding, then the summary line. The annotations sit at the
+* top level of `blocks`, not inside the file sections: the kit draws an
+* annotation only at the top level, as a top-level section's child, or as a
+* direct child of a group's body, so this placement survives the caller
+* wrapping `blocks` in a collapsible.
 *
 * @param dir - Path to the changeset directory (resolved relative to cwd)
-* @returns An Effect that performs validation and logs results
+* @returns The section; `verdict` is `failure` when any file has errors
 *
 * @internal
 */
-function runChangesetCheck(dir) {
+function changesetCheckSection(dir) {
 	return Effect.gen(function* () {
 		const resolved = resolve(dir);
 		const messages = yield* Effect.try({
@@ -54,22 +80,57 @@ function runChangesetCheck(dir) {
 			if (existing) existing.push(msg);
 			else byFile.set(msg.file, [msg]);
 		}
+		if (messages.length === 0) return {
+			title: SECTION_TITLE,
+			blocks: [Report.ok("All changeset files passed validation")],
+			verdict: "success",
+			fixedByInit: false
+		};
+		const cwd = resolve();
+		const blocks = [];
 		for (const [file, fileMessages] of byFile) {
-			yield* Output.line("");
-			yield* Output.heading(file);
-			for (const msg of fileMessages) yield* Output.detail(`${msg.line}:${msg.column}  ${msg.rule}  ${msg.message}`);
+			const display = displayPath(cwd, file);
+			blocks.push(Doc.section(Doc.file(display), [Doc.table(FINDING_COLUMNS, fileMessages.map((msg) => [
+				`${msg.line}:${msg.column}`,
+				msg.rule,
+				msg.message
+			]))]), ...fileMessages.map((msg) => Doc.annotation({
+				level: "error",
+				file: display,
+				line: msg.line,
+				col: msg.column,
+				title: msg.rule
+			}, msg.message)));
 		}
-		const errorCount = messages.length;
-		const filesWithErrors = byFile.size;
-		if (errorCount > 0) {
-			yield* Output.line("");
-			yield* Output.fail(`${filesWithErrors} file(s) with errors, ${errorCount} error(s) found`);
-			yield* CliExit.set(1);
-		} else yield* Output.ok("All changeset files passed validation");
+		blocks.push(Report.fail(`${byFile.size} file(s) with errors, ${messages.length} error(s) found`));
+		return {
+			title: SECTION_TITLE,
+			blocks,
+			verdict: "failure",
+			fixedByInit: false
+		};
+	});
+}
+/**
+* Run the check validation pipeline on all changeset files in `dir` and
+* print {@link changesetCheckSection}'s blocks (no title heading: the
+* standalone `savvy changeset check` output). Sets exit code 1 through
+* `CliExit.set` when one or more errors are found.
+*
+* @param dir - Path to the changeset directory (resolved relative to cwd)
+* @returns An Effect that performs validation and prints the report
+*
+* @internal
+*/
+function runChangesetCheck(dir) {
+	return Effect.gen(function* () {
+		const section = yield* changesetCheckSection(dir);
+		yield* Report.print(section.blocks);
+		if (section.verdict === "failure") yield* CliExit.set(1);
 	});
 }
 /* v8 ignore next 3 -- CLI registration; handler tested via runChangesetCheck */
 const checkCommand = Command.make("check", { dir: dirArg }, ({ dir }) => runChangesetCheck(dir)).pipe(Command.withDescription("Full changeset validation with summary"));
 
 //#endregion
-export { checkCommand, runChangesetCheck };
+export { changesetCheckSection, checkCommand, runChangesetCheck };

package/commands/changeset/commands/config-validate.js

@@ -1,6 +1,6 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { Argument, Command } from "effect/cli";
-import { resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { CliExit } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
@@ -30,8 +30,11 @@ const { ConfigInspector } = Changesets;
 /* v8 ignore next */
 const dirArg = Argument.Directory("dir").pipe(Argument.withDefault("."));
 /**
-* Run validation. Logs a one-line OK on success; logs the error and sets
-* exit code 1 through `CliExit.set` on failure.
+* Run validation and print the outcome as one stdout line: `✓ <config> —
+* N packages declared` on success, `✗ <config> — field: reason` plus exit
+* code 1 through `CliExit.set` on a finding. Both outcomes stay on stdout as
+* `Report` lines (not `CliMessage`, whose failure line goes to stderr), so a
+* gate reading the result reads one stream.
 *
 * @internal
 */
@@ -51,10 +54,10 @@ function runConfigValidate(dir) {
 			const { config } = result;
 			const pkgCount = config.packages.length;
 			const note = config.legacyVersionFilesUsed ? " (warning: legacy versionFiles in use)" : "";
-			yield* Output.ok(`${config.configPath} — ${pkgCount} package${pkgCount === 1 ? "" : "s"} declared${note}`);
+			yield* Report.print([Report.ok(`${config.configPath} — ${pkgCount} package${pkgCount === 1 ? "" : "s"} declared${note}`)]);
 			return;
 		}
-		yield* Output.fail(`${result.field}: ${result.reason}`);
+		yield* Report.print([Report.fail(`${join(resolved, ".changeset", "config.json")} — ${result.field}: ${result.reason}`)]);
 		yield* CliExit.set(1);
 	});
 }

package/commands/changeset/commands/deps-detect.js

@@ -1,4 +1,4 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { Command, Flag } from "effect/cli";
 import { resolve } from "node:path";
 import { CliExit } from "@effected/cli";
@@ -69,7 +69,7 @@ function runDepsDetect(cwd, from, to, pkg, json, markdown) {
 			...Option.isSome(to) ? { to: to.value } : {}
 		}).pipe(Effect.tapError(() => CliExit.set(1)))).toWrite.map((entry) => entry.diff);
 		if (markdown && !json) {
-			yield* Output.line(renderMarkdownBlocks(diffs));
+			yield* Report.print([Report.verbatim(renderMarkdownBlocks(diffs))]);
 			return;
 		}
 		yield* Console.log(JSON.stringify(diffs, null, 2));

package/commands/changeset/commands/deps-regen.js

@@ -1,7 +1,7 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { Command, Flag } from "effect/cli";
 import { resolve } from "node:path";
-import { CliExit } from "@effected/cli";
+import { CliExit, Doc } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Console, Effect, Option } from "effect";
 
@@ -41,9 +41,12 @@ import { Console, Effect, Option } from "effect";
 *
 * **Dry-run reporting.** With `--dry-run` nothing is written or deleted, so
 * the human output is phrased as a plan (`Would delete N pure dependency
-* changeset(s):` / `Would write N dependency changeset(s):`) rather than the
-* real run's `✓ Deleted …` / `✓ Wrote …`. A real run reports what
-* `execute()` returned, not what the plan listed: deletes are tolerant, so a
+* changeset(s):` / `Would write N dependency changeset(s):`, each over a
+* file / package (/ rows) table) rather than the
+* real run's `✓ Wrote …` / `✓ Deleted …`. A real run prints each write and
+* delete as `execute()` reports it landing (its `onStep`), so a run that
+* fails partway still shows what already reached disk; it reports what
+* `execute()` did, not what the plan listed: deletes are tolerant, so a
 * planned delete that found nothing or could not remove the file is reported
 * as not removed. `--json`
 * emits the plan's fields plus an explicit `dryRun` boolean in both modes,
@@ -79,57 +82,100 @@ function runDepsRegen(cwd, base, pkg, dryRun, json) {
 			...Option.isSome(base) ? { base: base.value } : {},
 			...Option.isSome(pkg) ? { package: pkg.value } : {}
 		}).pipe(Effect.tapError(() => CliExit.set(1)));
-		const result = dryRun ? void 0 : yield* service.execute(plan);
-		if (json) yield* Console.log(JSON.stringify({
-			...plan,
-			dryRun,
-			...result ? { result } : {}
-		}, null, 2));
-		else yield* renderHumanPlan(plan, result);
+		if (json) {
+			const result = dryRun ? void 0 : yield* service.execute(plan);
+			yield* Console.log(JSON.stringify({
+				...plan,
+				dryRun,
+				...result ? { result } : {}
+			}, null, 2));
+		} else if (dryRun) yield* renderDryRunPlan(plan);
+		else yield* runAndReport(plan, service);
 	});
 }
+/** The columns of a table of changesets to delete (or not removed). */
+const DELETE_COLUMNS = [{ header: "file" }, { header: "package" }];
+/** The columns of a table of changesets to write. */
+const WRITE_COLUMNS = [
+	{ header: "file" },
+	{ header: "package" },
+	{
+		header: "rows",
+		align: "right"
+	}
+];
+const row = (entry) => `${entry.file}  (${entry.package})`;
+const writeRow = (entry) => `${entry.file}  (${entry.package} — ${entry.diff.rows.length} row${entry.diff.rows.length === 1 ? "" : "s"})`;
 /**
-* Render the plan for a person. A dry run (no `result`) changed nothing, so its
-* headings are plan-phrased and carry no `✓`. A real run reports what
-* `execute` actually did: deletes are tolerant, so a planned delete absent from
-* `result.deleted` was already gone or could not be removed, and is reported as
-* not removed, never as deleted.
+* Apply the plan for a person, printing each write and delete as `execute`
+* reports it landing, so a failure partway still leaves what reached disk on
+* stdout. The closing summary covers what no step reported: a planned delete
+* absent from `result.deleted` was already gone or could not be removed, and
+* is reported as not removed, never as deleted. Only paths `execute` reports
+* are ever named as written or deleted.
 */
-function renderHumanPlan(plan, result) {
+function runAndReport(plan, service) {
 	return Effect.gen(function* () {
-		const dryRun = result === void 0;
-		if (plan.toDelete.length === 0 && plan.toWrite.length === 0) yield* Output.ok("No dependency changes to regenerate");
-		else {
-			if (dryRun && plan.toDelete.length > 0) {
-				yield* Output.heading(`Would delete ${plan.toDelete.length} pure dependency changeset(s):`);
-				for (const entry of plan.toDelete) yield* Output.detail(`${entry.file}  (${entry.package})`);
+		const writes = new Map(plan.toWrite.map((entry) => [entry.file, entry]));
+		const deletes = new Map(plan.toDelete.map((entry) => [entry.file, entry]));
+		const reported = /* @__PURE__ */ new Set();
+		const stepBlock = (step) => {
+			if (step._tag === "Written") {
+				const entry = writes.get(step.file);
+				return Report.ok(`Wrote ${entry ? writeRow(entry) : step.file}`);
 			}
-			if (!dryRun) {
-				const deleted = new Set(result.deleted);
-				const removed = plan.toDelete.filter((entry) => deleted.has(entry.file));
-				const notRemoved = plan.toDelete.filter((entry) => !deleted.has(entry.file));
-				if (removed.length > 0) {
-					yield* Output.ok(`Deleted ${removed.length} pure dependency changeset(s):`);
-					for (const entry of removed) yield* Output.detail(`${entry.file}  (${entry.package})`);
-				}
-				if (notRemoved.length > 0) {
-					yield* Output.skip(`${notRemoved.length} planned deletion(s) not removed (already gone or undeletable):`);
-					for (const entry of notRemoved) yield* Output.detail(`${entry.file}  (${entry.package})`);
-				}
-			}
-			const writes = dryRun ? plan.toWrite : plan.toWrite.filter((entry) => result.written.includes(entry.file));
-			if (writes.length > 0) {
-				yield* dryRun ? Output.heading(`Would write ${writes.length} dependency changeset(s):`) : Output.ok(`Wrote ${writes.length} fresh dependency changeset(s):`);
-				for (const entry of writes) yield* Output.detail(`+ ${entry.file}  (${entry.package} — ${entry.diff.rows.length} row${entry.diff.rows.length === 1 ? "" : "s"})`);
-			}
-		}
-		if (plan.skippedMixed.length > 0) {
-			yield* Output.line("");
-			yield* Output.skip(`Skipped ${plan.skippedMixed.length} mixed changeset(s) (have Dependencies but also other content):`);
-			for (const file of plan.skippedMixed) yield* Output.detail(`~ ${file}`);
-		}
+			const entry = deletes.get(step.file);
+			return Report.ok(`Deleted ${entry ? row(entry) : step.file}`);
+		};
+		const printStep = (step) => Effect.suspend(() => {
+			reported.add(`${step._tag}:${step.file}`);
+			return Report.print([stepBlock(step)]);
+		});
+		const result = yield* service.execute(plan, { onStep: printStep });
+		yield* renderRunSummary(plan, result, [...result.written.filter((file) => !reported.has(`Written:${file}`)).map((file) => stepBlock({
+			_tag: "Written",
+			file
+		})), ...result.deleted.filter((file) => !reported.has(`Deleted:${file}`)).map((file) => stepBlock({
+			_tag: "Deleted",
+			file
+		}))]);
 	});
 }
+/** The closing document of a real run: whatever no step printed, then the totals. */
+function renderRunSummary(plan, result, unreported) {
+	const blocks = [...unreported];
+	if (plan.toDelete.length === 0 && plan.toWrite.length === 0) blocks.push(Report.ok("No dependency changes to regenerate"));
+	else {
+		const deleted = new Set(result.deleted);
+		const notRemoved = plan.toDelete.filter((entry) => !deleted.has(entry.file));
+		if (notRemoved.length > 0) blocks.push(Report.skip(`${notRemoved.length} planned deletion(s) not removed (already gone or undeletable):`), Doc.table(DELETE_COLUMNS, notRemoved.map((entry) => [entry.file, entry.package])));
+		if (result.written.length > 0 || result.deleted.length > 0) blocks.push(Report.ok(`Wrote ${result.written.length} fresh and deleted ${result.deleted.length} pure dependency changeset(s)`));
+	}
+	return Report.print([...blocks, ...mixedBlocks(plan)]);
+}
+/**
+* Render a dry run for a person. Nothing changed, so its headings are
+* plan-phrased and carry no `✓`.
+*/
+function renderDryRunPlan(plan) {
+	const blocks = [];
+	if (plan.toDelete.length === 0 && plan.toWrite.length === 0) blocks.push(Report.ok("No dependency changes to regenerate"));
+	else {
+		if (plan.toDelete.length > 0) blocks.push(Doc.section(`Would delete ${plan.toDelete.length} pure dependency changeset(s):`, [Doc.table(DELETE_COLUMNS, plan.toDelete.map((entry) => [entry.file, entry.package]))]));
+		if (plan.toWrite.length > 0) blocks.push(Doc.section(`Would write ${plan.toWrite.length} dependency changeset(s):`, [Doc.table(WRITE_COLUMNS, plan.toWrite.map((entry) => [
+			entry.file,
+			entry.package,
+			String(entry.diff.rows.length)
+		]))]));
+	}
+	return Report.print([...blocks, ...mixedBlocks(plan)]);
+}
+/** The skipped-mixed note both a dry and a real run close with. */
+function mixedBlocks(plan) {
+	const blocks = [];
+	if (plan.skippedMixed.length > 0) blocks.push(Report.line(""), Report.skip(`Skipped ${plan.skippedMixed.length} mixed changeset(s) (have Dependencies but also other content):`, ...plan.skippedMixed.map((file) => `~ ${file}`)));
+	return blocks;
+}
 /* v8 ignore next 12 */
 const depsRegenCommand = Command.make("regen", {
 	cwd: cwdOption,

package/commands/changeset/commands/init.js

@@ -1,8 +1,10 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { CommandError } from "../../../internal/command-error.js";
 import { join } from "node:path";
-import { CliExit } from "@effected/cli";
+import { CliDoc, CliExit, Doc } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Data, Effect, Option, Result, Schema } from "effect";
+import { TerminalEnv } from "@effected/env";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { Git } from "@effected/git";
 import { Jsonc, JsoncEdit, JsoncModifier } from "@effected/jsonc";
@@ -555,17 +557,18 @@ function checkChangesetMarkdownlint(changesetDir) {
 	}
 }
 /**
-* Run the full init pipeline.
+* Run the full init pipeline, failing when a step fails.
 *
-* Exported so Task B5's unified `savvy init` orchestrator can invoke the
-* changeset init step directly without going through the CLI command layer.
+* Steps 3–5 each run even when an earlier one fails; the run then fails with
+* one {@link CommandError} listing every failed step. `quiet` swallows that
+* failure (and any other) instead.
 *
 * @param opts - The same options the CLI command receives
 * @returns An Effect that performs initialization
 *
 * @internal
 */
-function runChangesetInit(opts) {
+function runChangesetInitOrFail(opts) {
 	const { force, quiet, skipMarkdownlint, check } = opts;
 	return Effect.gen(function* () {
 		const root = yield* resolveWorkspaceRoot(process.cwd());
@@ -581,42 +584,72 @@ function runChangesetInit(opts) {
 				...checkChangesetMarkdownlint(changesetDir)
 			];
 			if (issues.length === 0) {
-				yield* Output.ok("All @savvy-web/changesets config files are up to date");
+				yield* Report.print([Report.ok("All @savvy-web/changesets config files are up to date")]);
 				return;
 			}
-			for (const issue of issues) yield* Output.warn(`${issue.file}: ${issue.message}`);
-			yield* Output.detail("Run \"savvy init --force\" to fix");
+			yield* Report.print([...issues.map((issue) => Report.warn(`${issue.file}: ${issue.message}`)), Report.detail("Run \"savvy init --force\" to fix")]);
 			return;
 		}
 		const changesetDir = yield* ensureChangesetDir(root);
-		yield* Output.ok("Ensured .changeset/ directory");
+		yield* Report.print([Report.ok("Ensured .changeset/ directory")]);
 		const errors = [];
 		const configResult = yield* handleConfig(changesetDir, repoSlug, force).pipe(Effect.result);
 		if (Result.isSuccess(configResult)) {
-			yield* Output.ok(configResult.success);
+			yield* Report.print([Report.ok(configResult.success)]);
 			if (!quiet) yield* warnIfLegacyVersionFiles(changesetDir);
 		} else errors.push(configResult.failure);
 		if (!skipMarkdownlint) {
 			const baseResult = yield* handleBaseMarkdownlint(root).pipe(Effect.result);
-			if (Result.isSuccess(baseResult)) yield* Output.ok(baseResult.success);
+			if (Result.isSuccess(baseResult)) yield* Report.print([Report.ok(baseResult.success)]);
 			else errors.push(baseResult.failure);
 		}
 		const mdlintResult = yield* handleChangesetMarkdownlint(changesetDir, root, force).pipe(Effect.result);
-		if (Result.isSuccess(mdlintResult)) yield* Output.ok(mdlintResult.success);
+		if (Result.isSuccess(mdlintResult)) yield* Report.print([Report.ok(mdlintResult.success)]);
 		else errors.push(mdlintResult.failure);
 		if (errors.length > 0) {
-			for (const err of errors) yield* Effect.logError(err.message);
-			if (!quiet) yield* CliExit.set(1);
-			return;
-		}
-		yield* Output.ok("Init complete");
-	}).pipe(Effect.catch((error) => Effect.gen(function* () {
-		if (!quiet) {
-			yield* Effect.logError(error instanceof InitError ? error.message : `Init failed: ${String(error)}`);
-			yield* CliExit.set(1);
+			if (quiet) return;
+			return yield* Effect.fail(new CommandError({
+				message: `changeset init could not finish ${errors.length} step(s)`,
+				detail: errors.map((err) => err.message),
+				hint: "Fix the files named above, then re-run \"savvy init\"."
+			}));
 		}
+		yield* Report.print([Report.ok("Init complete")]);
+	}).pipe(Effect.catch((error) => quiet ? Effect.void : Effect.fail(error instanceof CommandError ? error : CommandError.from(error, {
+		message: "changeset init failed",
+		hint: "Fix the problem above, then re-run \"savvy init\"."
+	}))));
+}
+/**
+* Run the changeset init as one step of the orchestrated `savvy init`: a
+* failure is reported, not propagated, so the commit and lint steps still
+* run.
+*
+* @remarks
+* Runs {@link runChangesetInitOrFail}. Its {@link CommandError} is drawn on
+* stderr exactly as the runtime draws a failure (its `CliDoc` document,
+* rendered for the audience; never wrapped off a terminal), exit code 1 is
+* set through `CliExit.set`, and the step succeeds. A caller that wants the
+* failure to end the run calls {@link runChangesetInitOrFail} instead.
+*
+* Exported so the unified `savvy init` orchestrator can invoke the changeset
+* init step directly without going through the CLI command layer.
+*
+* @param opts - The same options the CLI command receives
+* @returns An Effect that never fails
+*
+* @internal
+*/
+function runChangesetInit(opts) {
+	return runChangesetInitOrFail(opts).pipe(Effect.catchTag("CommandError", (error) => Effect.gen(function* () {
+		const terminal = yield* TerminalEnv;
+		yield* Doc.print(error[CliDoc](), {
+			stream: "stderr",
+			...terminal.stderr.isTerminal ? {} : { width: Number.POSITIVE_INFINITY }
+		});
+		yield* CliExit.set(1);
 	})));
 }
 
 //#endregion
-export { InitError, InitErrorBase, checkBaseMarkdownlint, checkChangesetDir, checkChangesetMarkdownlint, checkConfig, detectGitHubRepo, detectLegacyVersionFiles, ensureChangesetDir, findMarkdownlintConfig, handleBaseMarkdownlint, handleChangesetMarkdownlint, handleConfig, legacyVersionFilesWarning, resolveWorkspaceRoot, runChangesetInit, warnIfLegacyVersionFiles };
+export { InitError, InitErrorBase, checkBaseMarkdownlint, checkChangesetDir, checkChangesetMarkdownlint, checkConfig, detectGitHubRepo, detectLegacyVersionFiles, ensureChangesetDir, findMarkdownlintConfig, handleBaseMarkdownlint, handleChangesetMarkdownlint, handleConfig, legacyVersionFilesWarning, resolveWorkspaceRoot, runChangesetInit, runChangesetInitOrFail, warnIfLegacyVersionFiles };