reposets 2.0.4 → 3.1.0

package/cli/commands/sync.js

@@ -9,9 +9,12 @@ import { RepoCacheLive } from "../../store/RepoCache.js";
 import { PHASE_NAMES } from "../../sync/phase.js";
 import { allPhases } from "../../sync/phases/index.js";
 import { SyncEngine, SyncEngineLive } from "../../sync/SyncEngine.js";
-import { Console, Effect, Layer, Option } from "effect";
-import { CliExit } from "@effected/cli";
+import { syncSummaryBlock } from "../views/sync-progress-model.js";
+import { syncProgressView } from "../views/sync-progress-view.js";
+import { Console, Effect, Exit, Layer, Option, PubSub } from "effect";
+import { CliExit, CliInteractive, CliMessage, Doc } from "@effected/cli";
 import { CliError, Command, Flag } from "effect/cli";
+import { CliUi } from "@effected/cli/ui";
 import { CodeScanning, DeploymentEnvironment, GitHubClient, GitHubRepository, RepositorySecret, RepositorySecurity, RepositoryVariable, Ruleset, WorkflowDispatch } from "@effected/github";
 
 //#region src/cli/commands/sync.ts
@@ -61,12 +64,86 @@ const partitionByProfile = (groups, only) => {
 	return partitions;
 };
 /**
+* How many repositories a run will act on.
+*
+* @remarks
+* The engine's own selection rule, applied up front: every group the
+* partitions selected, each narrowed by a `--repo` filter. Computed before the
+* engine runs because a progress view needs its denominator at the start — the
+* engine only learns the count by walking the groups.
+*
+* Groups whose profile turns out to be missing or unresolvable are still
+* counted. They were selected; the summary saying `0/2 repos` beside an error
+* is the honest account of a run that skipped them.
+*
+* @public
+*/
+const selectedRepoCount = (groups, partitions, repo) => {
+	let total = 0;
+	for (const names of partitions.values()) for (const name of names) {
+		const repos = groups[name]?.repos ?? [];
+		total += repo === void 0 ? repos.length : repos.filter((r) => r === repo).length;
+	}
+	return total;
+};
+/**
+* Run `work` under a live sync progress view, and end the view on every exit.
+*
+* @remarks
+* Order matters at every step. The subscription is taken before `work`
+* publishes anything, and handed to the view itself rather than as a stream,
+* so `RunStarted` is never missed. `work` runs with the view's `logConsole` as
+* its `Console`, so every report line and every `Effect.logError` lands above
+* the frame.
+*
+* The view is closed on success, failure, defect and interruption alike, and
+* before the scope closes. `close` folds whatever is still queued and commits
+* the final frame; the bare scope close a failure would otherwise fall through
+* to stops the fold at once, dropping the tail and leaving a spinner frame on
+* the terminal as if the run were still going. When `work` did not end the
+* run itself — it failed before `finish` — a `RunEnded` with no totals is
+* published first, so the committed frame is the summary of what got done
+* rather than a frozen spinner. The failure then propagates unchanged.
+*
+* @param view - the view's options without `events`: the handler passes
+* `syncProgressView`, and a test the same value.
+* @param work - the run, given the `PubSub` to publish its events to.
+*
+* @public
+*/
+const runUnderSyncView = (view, work) => Effect.scoped(Effect.gen(function* () {
+	const pubsub = yield* PubSub.unbounded();
+	const events = yield* PubSub.subscribe(pubsub);
+	const handle = yield* CliUi.live({
+		...view,
+		events
+	});
+	return yield* work(pubsub).pipe(Effect.provideService(Console.Console, handle.logConsole), Effect.onExit((exit) => Exit.isSuccess(exit) ? handle.close : PubSub.publish(pubsub, { _tag: "RunEnded" }).pipe(Effect.andThen(handle.close))));
+}));
+/**
 * `reposets sync` — apply the config to every selected repository.
 *
 * @remarks
 * The layer graph is built here rather than at the entrypoint because it
 * depends on values only known after the config and credentials have loaded:
-* the GitHub token, and the logger's tier and dry-run flag.
+* the GitHub token, and the logger's dry-run flag and event sink.
+*
+* **Two ways to show progress, decided by `CliInteractive`.** A person at a
+* terminal gets a live footer (`CliUi.live`, hosted): a spinner, the current
+* repository and the counts so far, redrawn in place while the per-line report
+* scrolls above it. Every line — the report on stdout and every
+* `Effect.logError` on stderr — reaches the terminal through the view's
+* `logConsole`, provided as the fiber's `Console` around the whole run, so
+* nothing tears the frame. The view's committed final frame is the summary.
+*
+* Anyone else — a pipe, an agent, CI — gets no view and no React load: the
+* view's `render` is a `CliUi.lazyView`, and this path never mounts it. The same
+* summary block is printed statically with `Doc.print` instead.
+*
+* **Findings are failures, not diagnostics.** "No config found", a dangling
+* reference and a config with no groups exit 1 through `CliExit`, and they are
+* written with `CliMessage.failure` — on stderr, and unlike `Effect.logError`
+* never silenced by `--log-level`, because a run that did nothing must say why.
 *
 * @public
 */
@@ -77,7 +154,7 @@ const syncHandler = (input) => Effect.gen(function* () {
 	const credentialsFile = yield* ReposetsCredentialsFile;
 	const source = (yield* configFile.discover)[0];
 	if (source === void 0) {
-		yield* Effect.logError("No config found. Run 'reposets init' to create one.");
+		yield* CliMessage.failure("No config found. Run 'reposets init' to create one.");
 		return yield* CliExit.set(1);
 	}
 	const config = source.value;
@@ -85,92 +162,109 @@ const syncHandler = (input) => Effect.gen(function* () {
 	const credentials = yield* credentialsFile.loadOrDefault({ profiles: {} });
 	const dangling = danglingReferences(config);
 	if (dangling.length > 0) {
-		yield* Effect.logError("Config references sections that do not exist:");
-		for (const ref of dangling) {
-			const defined = ref.defined.length === 0 ? "none defined" : `defined: ${ref.defined.join(", ")}`;
-			yield* Effect.logError(`  ${ref.where}: '${ref.name}' does not exist — ${defined}`);
-		}
-		yield* Effect.logError("");
-		yield* Effect.logError("Nothing was synced. Fix the references or run 'reposets validate' for the full list.");
+		yield* CliMessage.failure("Config references sections that do not exist:");
+		yield* Doc.print([Doc.list(dangling.map((ref) => Doc.paragraph(`${ref.where}: '${ref.name}' does not exist — ${ref.defined.length === 0 ? "none defined" : `defined: ${ref.defined.join(", ")}`}`))), Doc.paragraph("Nothing was synced. Fix the references or run 'reposets validate' for the full list.")], { stream: "stderr" });
 		return yield* CliExit.set(1);
 	}
 	const partitions = partitionByProfile(config.groups, input.group);
 	if (partitions.size === 0) {
 		if (input.group !== void 0) return yield* Effect.fail(new CliError.UserError({ cause: `No group named '${input.group}'. Configured: ${Object.keys(config.groups).join(", ") || "none"}` }));
-		yield* Effect.logError("No groups configured. Add a [groups.<name>] section to sync anything.");
+		yield* CliMessage.failure("No groups configured. Add a [groups.<name>] section to sync anything.");
 		return yield* CliExit.set(1);
 	}
+	const total = selectedRepoCount(config.groups, partitions, input.repo);
 	const resolverLayer = Layer.provide(CredentialResolverLive, OnePasswordClientLive);
-	const loggerLayer = SyncLoggerLive({
-		dryRun: input.dryRun,
-		debug: input.debug
-	});
-	const sharedLayer = Layer.mergeAll(SyncJournalLive, AppliedStateLive, RepoCacheLive, resolverLayer, loggerLayer);
-	const report = yield* Effect.gen(function* () {
-		const journal = yield* SyncJournal;
-		const logger = yield* SyncLogger;
-		const resolver = yield* CredentialResolver;
-		const runId = yield* journal.startRun({
-			group: input.group,
-			dryRun: input.dryRun
-		}).pipe(Effect.orElseSucceed(() => "unrecorded"));
-		let repos = 0;
-		let changes = 0;
-		let drifted = 0;
-		let errors = 0;
-		let firstError;
-		for (const [profileName, groupNames] of partitions) {
-			const profile = credentials.profiles[profileName];
-			if (profile === void 0) {
-				const message = `credential profile '${profileName}' does not exist (has: ${Object.keys(credentials.profiles).join(", ") || "none — run 'reposets credentials create'"}); skipping ${groupNames.join(", ")}`;
-				yield* logger.syncError(`profile ${profileName}`, message);
-				errors += 1;
-				firstError ??= `profile ${profileName}: ${message}`;
-				continue;
-			}
-			const resolved = yield* resolver.resolveGitHubToken(profile).pipe(Effect.result);
-			if (resolved._tag === "Failure") {
-				const message = `could not resolve the GitHub token for profile '${profileName}' — ${resolved.failure.reason}`;
-				yield* logger.syncError(`profile ${profileName}`, message);
-				errors += 1;
-				firstError ??= `profile ${profileName}: ${message}`;
-				continue;
+	/**
+	* The run itself, publishing to `events` when a view is drawn.
+	*
+	* @remarks
+	* The shared layer is built once and provided around the WHOLE loop
+	* rather than per partition. Layers memoize per build, so providing these
+	* inside the loop would mint a logger per profile — each with its own
+	* error tally, so `finish()` would report one partition's errors and call
+	* it the run — plus a separate journal and cache connection per profile.
+	*/
+	const runSync = (events) => {
+		const loggerLayer = SyncLoggerLive({
+			dryRun: input.dryRun,
+			debug: input.debug,
+			events
+		});
+		const sharedLayer = Layer.mergeAll(SyncJournalLive, AppliedStateLive, RepoCacheLive, resolverLayer, loggerLayer);
+		return Effect.gen(function* () {
+			const journal = yield* SyncJournal;
+			const logger = yield* SyncLogger;
+			const resolver = yield* CredentialResolver;
+			yield* logger.runStart(total);
+			const runId = yield* journal.startRun({
+				group: input.group,
+				dryRun: input.dryRun
+			}).pipe(Effect.orElseSucceed(() => "unrecorded"));
+			let repos = 0;
+			let changes = 0;
+			let drifted = 0;
+			let errors = 0;
+			let firstError;
+			for (const [profileName, groupNames] of partitions) {
+				const profile = credentials.profiles[profileName];
+				if (profile === void 0) {
+					const message = `credential profile '${profileName}' does not exist (has: ${Object.keys(credentials.profiles).join(", ") || "none — run 'reposets credentials create'"}); skipping ${groupNames.join(", ")}`;
+					yield* logger.syncError(`profile ${profileName}`, message);
+					errors += 1;
+					firstError ??= `profile ${profileName}: ${message}`;
+					continue;
+				}
+				const resolved = yield* resolver.resolveGitHubToken(profile).pipe(Effect.result);
+				if (resolved._tag === "Failure") {
+					const message = `could not resolve the GitHub token for profile '${profileName}' — ${resolved.failure.reason}`;
+					yield* logger.syncError(`profile ${profileName}`, message);
+					errors += 1;
+					firstError ??= `profile ${profileName}: ${message}`;
+					continue;
+				}
+				const token = resolved.success;
+				const services = Layer.mergeAll(GitHubRepository.layer, Ruleset.layer, RepositorySecurity.layer, CodeScanning.layer, DeploymentEnvironment.layer, RepositorySecret.layer, RepositoryVariable.layer, WorkflowDispatch.layer).pipe(Layer.provideMerge(GitHubClient.layerFromToken({ token })));
+				const engineLayer = SyncEngineLive(allPhases).pipe(Layer.provide(services));
+				const scoped = {
+					...config,
+					groups: Object.fromEntries(groupNames.map((name) => [name, config.groups[name]]))
+				};
+				const partial = yield* Effect.gen(function* () {
+					return yield* (yield* SyncEngine).syncAll(scoped, credentials, {
+						runId,
+						dryRun: input.dryRun,
+						noCleanup: input.noCleanup,
+						configDir,
+						group: input.group,
+						repo: input.repo,
+						only: phaseSet(input.only),
+						skip: phaseSet(input.skip)
+					});
+				}).pipe(Effect.provide(engineLayer));
+				repos += partial.repos;
+				changes += partial.changes;
+				drifted += partial.drifted;
+				errors += partial.errors;
+				if (partial.errorSummary !== void 0) firstError ??= partial.errorSummary;
 			}
-			const token = resolved.success;
-			const services = Layer.mergeAll(GitHubRepository.layer, Ruleset.layer, RepositorySecurity.layer, CodeScanning.layer, DeploymentEnvironment.layer, RepositorySecret.layer, RepositoryVariable.layer, WorkflowDispatch.layer).pipe(Layer.provideMerge(GitHubClient.layerFromToken({ token })));
-			const engineLayer = SyncEngineLive(allPhases).pipe(Layer.provide(services));
-			const scoped = {
-				...config,
-				groups: Object.fromEntries(groupNames.map((name) => [name, config.groups[name]]))
+			const summary = {
+				repos,
+				changes,
+				drifted,
+				errors
 			};
-			const partial = yield* Effect.gen(function* () {
-				return yield* (yield* SyncEngine).syncAll(scoped, credentials, {
-					runId,
-					dryRun: input.dryRun,
-					noCleanup: input.noCleanup,
-					configDir,
-					group: input.group,
-					repo: input.repo,
-					only: phaseSet(input.only),
-					skip: phaseSet(input.skip)
-				});
-			}).pipe(Effect.provide(engineLayer));
-			repos += partial.repos;
-			changes += partial.changes;
-			drifted += partial.drifted;
-			errors += partial.errors;
-			if (partial.errorSummary !== void 0) firstError ??= partial.errorSummary;
-		}
-		yield* journal.finishRun(runId, errors === 0 ? "success" : "partial", firstError).pipe(Effect.ignore);
-		yield* logger.finish();
-		return {
-			repos,
-			changes,
-			drifted,
-			errors
-		};
-	}).pipe(Effect.provide(sharedLayer));
-	yield* Console.log(`${report.repos} repo(s), ${report.changes} change(s), ${report.drifted} drifted, ${report.errors} error(s)`);
+			yield* journal.finishRun(runId, errors === 0 ? "success" : "partial", firstError).pipe(Effect.ignore);
+			yield* logger.finish(summary);
+			return summary;
+		}).pipe(Effect.provide(sharedLayer));
+	};
+	const interactive = yield* CliInteractive;
+	const report = interactive ? yield* runUnderSyncView(syncProgressView, runSync) : yield* runSync(void 0);
+	if (!interactive) yield* Doc.print([syncSummaryBlock({
+		dryRun: input.dryRun,
+		total,
+		...report
+	})]);
 	if (report.errors > 0 || input.failOnDrift && report.drifted > 0) yield* CliExit.set(1);
 });
 /**
@@ -199,4 +293,4 @@ const syncCommand = Command.make("sync", {
 })).pipe(Command.withDescription("Apply the config to every repository in a group, or all groups"));
 
 //#endregion
-export { partitionByProfile, syncCommand, syncHandler };
+export { partitionByProfile, runUnderSyncView, selectedRepoCount, syncCommand, syncHandler };

package/cli/commands/validate.js

@@ -2,12 +2,33 @@ import { ReposetsConfigFile, ReposetsCredentialsFile } from "../../services/Conf
 import { danglingReferences } from "../../lib/config-refs.js";
 import { undefinedCredentialLabels } from "../../lib/credential-labels.js";
 import { orgOnlyViolations } from "../../lib/org-only.js";
-import { Console, Effect } from "effect";
-import { CliExit } from "@effected/cli";
+import { Effect } from "effect";
+import { CliExit, CliMessage, Doc, Status } from "@effected/cli";
 import { Command } from "effect/cli";
 
 //#region src/cli/commands/validate.ts
 /**
+* Findings grouped by the group that references them, as a document.
+*
+* @remarks
+* Grouped because that is the unit a reader fixes: every finding sits in a
+* `[groups.<name>]` table, and seeing all of one group's problems together is
+* one trip into the file rather than several. Each finding keeps its full
+* config path — the problem is reported where the reference is **used**, which
+* is where the edit goes. The optional `hint` closes the report with the fix
+* that applies to every finding in it.
+*/
+const findingsDoc = (findings, hint) => {
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const finding of findings) {
+		const existing = byGroup.get(finding.group);
+		if (existing === void 0) byGroup.set(finding.group, [finding.text]);
+		else existing.push(finding.text);
+	}
+	const sections = [...byGroup].map(([group, texts]) => Doc.section(`[${group}]`, [Doc.list(texts.map((text) => Doc.paragraph(Doc.status(Status.core, "failure"), " ", text)), { compact: true })]));
+	return [Doc.section(void 0, hint === void 0 ? sections : [...sections, Doc.paragraph(hint)])];
+};
+/**
 * `reposets validate` — discovers, decodes and reports the config file.
 *
 * @remarks
@@ -19,9 +40,11 @@ import { Command } from "effect/cli";
 * The handler simply *requires* `ReposetsConfigFile`; how it gets built from
 * `--config` is the root command's business, not this command's.
 *
-* The success result goes to stdout. A reference or credential problem is a
-* finding, not a failure: the details go to stderr and the command succeeds
-* with `CliExit.set(1)`. A file that does not decode fails `discover`, and the
+* The success result goes to stdout as a `CliMessage.success` line. A
+* reference or credential problem is a finding, not a failure: an `Invalid:`
+* line (`CliMessage.failure`, which no log level silences) and the grouped
+* findings document go to stderr, and the command succeeds with
+* `CliExit.set(1)`. A file that does not decode fails `discover`, and the
 * entrypoint's renderer prints the issue lines and exits `1`.
 *
 * @public
@@ -29,37 +52,37 @@ import { Command } from "effect/cli";
 const validateHandler = Effect.gen(function* () {
 	const configFile = yield* ReposetsConfigFile;
 	const credentialsFile = yield* ReposetsCredentialsFile;
-	const sources = yield* configFile.discover;
-	const value = yield* configFile.load;
-	const credentials = yield* credentialsFile.loadOrDefault({ profiles: {} });
-	const dangling = danglingReferences(value);
-	if (dangling.length > 0) {
-		yield* Effect.logError(`Invalid: ${sources[0]?.path ?? "config"}`);
-		for (const ref of dangling) {
-			const defined = ref.defined.length === 0 ? "none defined" : `defined: ${ref.defined.join(", ")}`;
-			yield* Effect.logError(`  ${ref.where}: '${ref.name}' does not exist — ${defined}`);
-		}
+	const source = (yield* configFile.discover)[0];
+	if (source === void 0) {
+		yield* CliMessage.failure("No config found. Run 'reposets init' to create one.");
 		return yield* CliExit.set(1);
 	}
+	const value = source.value;
+	const where = source.path;
+	const credentials = yield* credentialsFile.loadOrDefault({ profiles: {} });
+	const invalid = (doc) => Effect.gen(function* () {
+		yield* CliMessage.failure(`Invalid: ${where}`);
+		yield* Doc.print(doc, { stream: "stderr" });
+		return yield* CliExit.set(1);
+	});
+	const dangling = danglingReferences(value);
+	if (dangling.length > 0) return yield* invalid(findingsDoc(dangling.map((ref) => ({
+		group: ref.group,
+		text: `${ref.where}: '${ref.name}' does not exist — ${ref.defined.length === 0 ? "none defined" : `defined: ${ref.defined.join(", ")}`}`
+	}))));
 	const labels = undefinedCredentialLabels(value, credentials);
 	const violations = orgOnlyViolations(value, credentials);
-	if (labels.length > 0) {
-		yield* Effect.logError(`Invalid: ${sources[0]?.path ?? "config"}`);
-		for (const label of labels) yield* Effect.logError(`  [${label.group}] ${label.where}: credential label '${label.label}' is not declared in profile '${label.profile}'`);
-		yield* Effect.logError("");
-		yield* Effect.logError("Add it to that profile's [resolve] section in reposets.credentials.toml, or correct the name.");
-		return yield* CliExit.set(1);
-	}
-	if (violations.length > 0) {
-		yield* Effect.logError(`Invalid: ${sources[0]?.path ?? "config"}`);
-		for (const violation of violations) yield* Effect.logError(`  [${violation.group}] ${violation.where}: ${violation.detail}, but profile '${violation.profile}' is a personal account`);
-		yield* Effect.logError("");
-		yield* Effect.logError("Either move these repositories to a profile declaring `org`, or drop the settings.");
-		return yield* CliExit.set(1);
-	}
+	if (labels.length > 0) return yield* invalid(findingsDoc(labels.map((label) => ({
+		group: label.group,
+		text: `${label.where}: credential label '${label.label}' is not declared in profile '${label.profile}'`
+	})), "Add it to that profile's [resolve] section in reposets.credentials.toml, or correct the name."));
+	if (violations.length > 0) return yield* invalid(findingsDoc(violations.map((violation) => ({
+		group: violation.group,
+		text: `${violation.where}: ${violation.detail}, but profile '${violation.profile}' is a personal account`
+	})), "Either move these repositories to a profile declaring `org`, or drop the settings."));
 	const groups = Object.keys(value.groups).length;
-	yield* Console.log(`Valid: ${sources[0]?.path ?? "config"}`);
-	yield* Console.log(`  groups: ${groups === 0 ? "none declared yet" : String(groups)}`);
+	yield* CliMessage.success(`Valid: ${where}`);
+	yield* Doc.print([Doc.verbatim(`groups: ${groups === 0 ? "none declared yet" : String(groups)}`, { indent: 2 })]);
 });
 /**
 * The `validate` command.

package/cli/views/sync-progress-model.js

@@ -0,0 +1,143 @@
+import { Doc, Status } from "@effected/cli";
+
+//#region src/cli/views/sync-progress-model.ts
+/**
+* The state before any event.
+*
+* @public
+*/
+const initialSyncProgress = {
+	dryRun: false,
+	total: 0,
+	repos: 0,
+	changes: 0,
+	drifted: 0,
+	errors: 0,
+	current: void 0,
+	finished: false
+};
+/**
+* Fold one event into the progress state.
+*
+* @remarks
+* The live counts are the view's own approximation — one per operation line,
+* one per drift line — because the engine counts journal changes, which a
+* settings write can make several of. `RunEnded` carries the engine's totals
+* and replaces them, so the committed final frame says exactly what the static
+* summary of a non-interactive run says.
+*
+* `repos` counts repositories *finished*: a repository is done when the next
+* one starts. A `RunEnded` with no totals is a run that did not finish (the
+* handler publishes one when the work fails or is interrupted), so it keeps
+* every live count and does not count the repository in flight as done.
+*
+* @public
+*/
+const reduceSyncProgress = (state, event) => {
+	switch (event._tag) {
+		case "RunStarted": return {
+			...initialSyncProgress,
+			total: event.total,
+			dryRun: event.dryRun
+		};
+		case "GroupStarted": return state;
+		case "RepoStarted": return {
+			...state,
+			repos: state.current === void 0 ? state.repos : state.repos + 1,
+			current: event.slug
+		};
+		case "Operation": return event.verb === "skip" ? state : {
+			...state,
+			changes: state.changes + event.count
+		};
+		case "Drift": return {
+			...state,
+			drifted: state.drifted + 1
+		};
+		case "Error": return {
+			...state,
+			errors: state.errors + 1
+		};
+		case "RunEnded": return {
+			...state,
+			repos: event.repos ?? state.repos,
+			changes: event.changes ?? state.changes,
+			drifted: event.drifted ?? state.drifted,
+			errors: event.errors ?? state.errors,
+			current: void 0,
+			finished: true
+		};
+	}
+};
+/**
+* A run begins at `RunStarted`.
+*
+* @public
+*/
+const isSyncRunStart = (event) => event._tag === "RunStarted";
+/**
+* A run ends at `RunEnded`, whose frame is committed as the summary.
+*
+* @public
+*/
+const isSyncRunEnd = (event) => event._tag === "RunEnded";
+/**
+* The run's counts as one document block: `Dry run: 2/3 repos, 4 changes, 1
+* drifted, 0 errors`.
+*
+* @remarks
+* The one summary both paths draw — the live view inside its frame through
+* `DocView`, a non-interactive run as a static `Doc.print` — so the two read
+* byte for byte alike. Every counter shows at zero: `0 errors` is the line a
+* reader looks for, and a counter that vanishes at zero makes the line change
+* shape between runs.
+*
+* Plurals are the kit's `{ one, other }` labels. A counter shown as a share
+* of the headline's total — `repos` — agrees with that total (`0/1 repo`,
+* `1/3 repos`); every other counter agrees with its own count.
+*
+* @public
+*/
+const syncSummaryBlock = (state) => Doc.counts({
+	layout: "inline",
+	label: state.dryRun ? "Dry run" : "Sync",
+	total: () => state.total,
+	counters: [
+		Doc.counter(Status.core, "success", {
+			key: "repos",
+			label: {
+				one: "repo",
+				other: "repos"
+			},
+			n: state.repos,
+			showZero: true
+		}),
+		Doc.counter(Status.core, "info", {
+			key: "changes",
+			label: {
+				one: "change",
+				other: "changes"
+			},
+			n: state.changes,
+			showZero: true
+		}),
+		Doc.counter(Status.core, "warning", {
+			key: "drifted",
+			label: "drifted",
+			n: state.drifted,
+			showZero: true
+		}),
+		Doc.counter(Status.core, "failure", {
+			key: "errors",
+			label: {
+				one: "error",
+				other: "errors"
+			},
+			n: state.errors,
+			showZero: true
+		})
+	]
+});
+
+//#endregion
+export { initialSyncProgress, isSyncRunEnd, isSyncRunStart, reduceSyncProgress, syncSummaryBlock };

package/cli/views/sync-progress-view.js

@@ -0,0 +1,32 @@
+import { initialSyncProgress, isSyncRunEnd, isSyncRunStart, reduceSyncProgress } from "./sync-progress-model.js";
+import { CliUi } from "@effected/cli/ui";
+
+//#region src/cli/views/sync-progress-view.ts
+/**
+* The sync progress view: every `CliUi.live` option but `events`.
+*
+* @remarks
+* Defined once and exported so the handler and its tests drive the same value —
+* a test that rebuilt the options would exercise a copy. `hosted` because a
+* run that cannot draw (a pipe, an agent, CI) has its own closing output — the
+* static summary `sync` prints — so the view must print nothing there; the
+* handler does not mount it on such a run in the first place.
+*
+* `render` is `CliUi.lazyView`: the JSX module is imported only when a run
+* first draws, so importing this module — and `sync` — loads neither React
+* nor Ink. It lives apart from the model because the JSX module imports the
+* model, and a lazy import back into it is still an import cycle.
+*
+* @public
+*/
+const syncProgressView = {
+	initial: initialSyncProgress,
+	reduce: reduceSyncProgress,
+	render: CliUi.lazyView(() => import("./sync-progress.js").then((module) => module.syncProgressRender)),
+	isStart: isSyncRunStart,
+	isTerminal: isSyncRunEnd,
+	mode: "hosted"
+};
+
+//#endregion
+export { syncProgressView };

package/cli/views/sync-progress.js

@@ -0,0 +1,55 @@
+import { syncSummaryBlock } from "./sync-progress-model.js";
+import { Fmt } from "@effected/cli";
+import { DocView, Styled, useGlyphs } from "@effected/cli/ui";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/cli/views/sync-progress.tsx
+/**
+* The redrawing footer of an interactive `sync` or `drift`.
+*
+* @remarks
+* While the run goes: a spinner, the repository being worked on, and the
+* counts so far. Once `RunEnded` arrives the spinner line goes and only the
+* counts remain — that frame is committed to the terminal, so it IS the run's
+* closing summary, the same block a non-interactive run prints statically.
+*
+* A component rather than a bare function so the glyph hook runs inside the
+* providers the live view mounts it under.
+*/
+const SyncProgress = (props) => {
+	const glyphs = useGlyphs();
+	const { state, frame } = props;
+	const summary = /* @__PURE__ */ jsx(DocView, { doc: syncSummaryBlock(state) });
+	if (state.finished) return summary;
+	const spinner = glyphs.spinner[frame % glyphs.spinner.length] ?? "";
+	const doing = state.dryRun ? "checking" : "syncing";
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Text, { children: [
+			/* @__PURE__ */ jsx(Styled, {
+				token: "accent",
+				children: spinner
+			}),
+			" ",
+			state.current === void 0 ? "starting…" : `${doing} ${Fmt.sanitize(state.current)}`
+		] }), summary]
+	});
+};
+/**
+* The sync progress view's `render`.
+*
+* @remarks
+* This module is the only one that holds JSX. It is loaded through
+* `CliUi.lazyView` by `syncProgressView` in `sync-progress-view.ts`, so only
+* a run that draws it ever loads React or Ink.
+*
+* @public
+*/
+const syncProgressRender = (state, frame) => /* @__PURE__ */ jsx(SyncProgress, {
+	state,
+	frame
+});
+
+//#endregion
+export { syncProgressRender };