@orkestrel/scaffold 0.0.22 → 0.0.24

package/dist/bin/scaffold.js

@@ -1,1896 +0,0 @@
-#!/usr/bin/env node
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import * as tls from "node:tls";
-import { CATALOG_AGENT_PATH, DEPENDENCY_NAME_PATTERN, ENVIRONMENTS, GROUPS, MAX_ARTIFACT_BYTES, NAME_PATTERN, SERVICE_SCRIPT_PATH, ScaffoldError, blueprint, catalogNames, catalogToBlock, createCompiler, dependency, diffPlan, isScaffoldError, manifestToDependencies, manifestToName, ownDataValue, planToSummary } from "../src/core/index.js";
-import { WriteTransaction, catalogPackages, commitWriteTransaction, createMaterializer, createSync, deriveBlueprint, digestFile, digestText, discardWriteTransaction, discoverPackages, hostRoot, hydratePlan, isFilesystemPath, isRealDirectory, isTerminalText, isVacant, locateHostSource, parseSyncOptions, pruneTargets, readFileText, readHostManifest, readManifest, readTarget, resolvePhysicalPath, validateWriteDirectories } from "../src/server/index.js";
-import { createReporter, createSpinner, createStyler } from "@orkestrel/console";
-import { createServerSink } from "@orkestrel/console/server";
-import { attempt, isRecord, parseJSON } from "@orkestrel/contract";
-import { isTerminalError } from "@orkestrel/terminal";
-import { createTerminal } from "@orkestrel/terminal/server";
-import { parseArgs } from "node:util";
-//#region src/bin/constants.ts
-/** The command-line interface's closed command vocabulary. */
-var KNOWN_VERBS = Object.freeze([
-	"new",
-	"pull",
-	"mirror",
-	"audit",
-	"repair",
-	"fleet",
-	"catalog"
-]);
-/** Internal artifact origins translated into user-facing labels. */
-var ORIGIN_LABEL = Object.freeze({
-	host: "host-owned",
-	template: "starter",
-	computed: "generated"
-});
-/** Internal drift states translated into user-facing labels. */
-var DRIFT_LABEL = Object.freeze({
-	aligned: "unchanged",
-	stale: "drifted",
-	missing: "missing",
-	foreign: "unexpected file"
-});
-/** Dependency freshness states translated into user-facing labels. */
-var FRESHNESS_LABEL = Object.freeze({
-	current: "unchanged",
-	behind: "behind",
-	missing: "missing upstream",
-	failed: "fetch failed"
-});
-/** Materializer actions translated into user-facing labels. */
-var ACTION_LABEL = Object.freeze({
-	written: "wrote",
-	copied: "wrote",
-	skipped: "unchanged",
-	removed: "removed"
-});
-/** The deliberately limited ownership boundary every write verb repairs within. */
-var REPAIR_SCOPE = "shared host-owned artifacts and absent service seams — missing files are restored; drifted files change only with --replace, which discards local changes; present starter and generated files are never touched";
-/** The opt-in generated-canon ownership boundary `--generated` widens that write to. */
-var REPAIR_GENERATED_SCOPE = "shared host-owned and generated artifacts plus service manifest scripts — missing files are restored; drifted files change only with --replace, which discards local changes; present starter files and package publication metadata are never touched";
-/** The dry-run note for `new`. */
-var NEW_DRY_RUN_NOTE = "dry run — pass --apply to write";
-/** The fallback message for a malformed command line without an error message. */
-var INVALID_ARGUMENTS_MESSAGE = "invalid arguments";
-/** Shared prompt-cancellation message. */
-var CANCELLED_MESSAGE = "cancelled — nothing written";
-/** Terminal choices for a new workspace's src and app environments. */
-var ENVIRONMENT_CHOICES = Object.freeze([
-	{
-		name: "core",
-		value: "core",
-		description: "the pure engine"
-	},
-	{
-		name: "browser",
-		value: "browser",
-		description: "DOM-facing environment"
-	},
-	{
-		name: "server",
-		value: "server",
-		description: "node-facing environment"
-	}
-]);
-/** The safety model included in full help. */
-var SAFETY_BANNER = [
-	"safety: every verb is a dry run by default.",
-	"on a terminal, a write prompts for confirmation; in a script, pass --apply (and --yes to skip the confirm).",
-	"every write is confined to the current working directory — cd there first.",
-	"when Node exposes system-CA controls, TLS adds the OS certificate store; earlier supported Node 22 releases use default roots. NODE_EXTRA_CA_CERTS adds custom PEMs."
-].join("\n");
-/** Stable command exit-code meanings. */
-var EXIT_CODES = Object.freeze([
-	["0", "clean / success"],
-	["1", "drift or failure"],
-	["2", "usage error"]
-]);
-/** One-line command summaries. */
-var VERB_SUMMARY = Object.freeze({
-	new: "scaffold a workspace into ./<name>",
-	pull: "refresh vendored guides/versions, report drift",
-	mirror: "refresh every published Orkestrel package guide",
-	audit: "whole-plan conformance report",
-	repair: "restore missing host-owned files; replace drifted bytes only with --replace",
-	fleet: "audit/repair every workspace under the cwd's immediate children",
-	catalog: "regenerate the fleet package-catalog table"
-});
-/** Compact command flag references. */
-var VERB_FLAGS = Object.freeze({
-	new: "--src a,b --app a,b --deps x,y --apply --yes --target <path> --from <path>",
-	pull: "--target . --deps x,y --apply --yes --strict",
-	mirror: "--target . --apply --yes --strict",
-	audit: "--target . --live --generated --replace --from <path> --groups a,b",
-	repair: "--target . --generated --replace --apply --yes --prune --from <path>",
-	fleet: "--generated --replace --apply --yes --prune --from <path>",
-	catalog: "--from <path> ... --target <repo> --offline --apply --yes"
-});
-/** Plain-language command flag descriptions. */
-var VERB_FLAG_HELP = Object.freeze({
-	new: [
-		["--src a,b", "which src environments to include (core, browser, server)"],
-		["--app a,b", "which app environments to include (core, browser, server)"],
-		["--deps x,y", "@orkestrel/* dependencies to add (installed as dependencies)"],
-		["--apply", "write the files (default is a dry run)"],
-		["--yes", "skip the confirmation question"],
-		["--target <path>", "destination directory (default: ./<name>)"],
-		["--from <path>", "read the template from a local path instead of the bundled one"]
-	],
-	pull: [
-		["--target .", "directory to refresh (default: current directory)"],
-		["--deps x,y", "limit the refresh to these dependencies"],
-		["--apply", "write the refreshed files (default is a dry run)"],
-		["--yes", "skip the confirmation question"],
-		["--strict", "fail (exit 1) on any drift, even non-fatal"]
-	],
-	mirror: [
-		["--target .", "directory whose guide mirror is refreshed (default: current directory)"],
-		["--apply", "write the refreshed guides (default is a dry run)"],
-		["--yes", "skip the confirmation question"],
-		["--strict", "fail immediately when an upstream guide cannot be fetched"]
-	],
-	audit: [
-		["--target .", "directory to audit (default: current directory)"],
-		["--live", "also check upstream freshness over the network"],
-		["--generated", "widen an accepted repair hand-off to generated files"],
-		["--replace", "let the repair hand-off discard local changes in the drifted files it names"],
-		["--from <path>", "read the template from a local path instead of the bundled one"],
-		["--groups a,b", "limit the audit to these artifact groups"]
-	],
-	repair: [
-		["--target .", "directory to repair (default: current directory)"],
-		["--generated", "widen the scope to generated files, except package.json"],
-		["--replace", "discard local changes in the drifted files named by the repair report"],
-		["--apply", "write the fixes (default is a dry run)"],
-		["--yes", "skip the confirmation question"],
-		["--prune", "also DELETE unexpected files under .claude/agents, .codex/agents, and scripts"],
-		["--from <path>", "read the template from a local path instead of the bundled one"]
-	],
-	fleet: [
-		["--generated", "widen the scope to generated files in every package, except package.json"],
-		["--replace", "discard local changes in the drifted files named in each package"],
-		["--apply", "write fixes across every package (default is a dry run)"],
-		["--yes", "skip the confirmation question"],
-		["--prune", "also DELETE unexpected files under .claude/agents, .codex/agents, and scripts, per package"],
-		["--from <path>", "read the template from a local path instead of the bundled one"]
-	],
-	catalog: [
-		["--from <path> ...", "one or more local package paths to include"],
-		["--target <repo>", "the repository whose Orkestrel agent catalog table gets updated"],
-		["--offline", "skip network lookups (npm registry) for package descriptions"],
-		["--apply", "write the updated table (default is a dry run)"],
-		["--yes", "skip the confirmation question"]
-	]
-});
-/** Dry-run and confirmation notes per command. */
-var VERB_DRY_RUN_NOTE = Object.freeze({
-	new: "dry run by default — add --apply to write the files, --yes to skip the question",
-	pull: "dry run by default — add --apply to write the refreshed files, --yes to skip the question",
-	mirror: "dry run by default — add --apply to write every published package guide, --yes to skip the question",
-	audit: "read-only — audit never writes; pass --live to also check upstream freshness",
-	repair: "dry run by default — add --apply to write, --yes to skip the question",
-	fleet: "dry run by default — add --apply to write across every package, --yes to skip the question",
-	catalog: "dry run by default — add --apply to write, --yes to skip the question"
-});
-/** One concrete invocation per command. */
-var VERB_EXAMPLE = Object.freeze({
-	new: "example: scaffold new widget --src core,server --app core,browser --apply",
-	pull: "example: scaffold pull --apply",
-	mirror: "example: scaffold mirror --apply --yes",
-	audit: "example: scaffold audit --live",
-	repair: "example: scaffold repair --apply",
-	fleet: "example: scaffold fleet --apply --yes",
-	catalog: "example: scaffold catalog --apply"
-});
-/** Message used when a prune scan has no candidates. */
-var PRUNE_EMPTY = "no unexpected files to delete";
-/** Guidance for unexpected files outside a non-pruning repair handoff. */
-var FOREIGN_HINT = "unexpected files are never deleted by default — run 'scaffold repair --prune --apply' to delete them; a file you added yourself is unexpected too, so check the paths above first";
-/** Interactive dependency prompt. */
-var ORKESTREL_DEPS_PROMPT = "@orkestrel dependencies (comma-separated short names, e.g. contract, emitter — installed as dependencies)";
-/** Catalog-degraded validation note. */
-var CATALOG_UNRESOLVED_NOTE = "couldn't resolve the vendored @orkestrel catalog — validating names by shape only";
-/** Opening marker for the generated package catalog block. */
-var CATALOG_START_MARKER = "<!-- catalog:start -->";
-/** Closing marker for the generated package catalog block. */
-var CATALOG_END_MARKER = "<!-- catalog:end -->";
-/** Non-terminal prune safety note. */
-var PRUNE_SKIPPED = "prune skipped — pass --apply to authorize deletion; --yes only skips confirmation";
-/** Degraded unexpected-file scan note. */
-var SCAN_SKIPPED = "unexpected-file scanning skipped — couldn't establish the template source";
-//#endregion
-//#region src/bin/errors.ts
-/** Internal sentinel that unwinds command dispatch without bypassing cleanup. */
-var CLIExitError = class extends Error {
-	code;
-	constructor(code) {
-		super(`cli-exit:${String(code)}`);
-		this.code = code;
-	}
-};
-//#endregion
-//#region src/bin/shapers.ts
-/** Partition findings by whether repair owns their artifact origin. The `owned` and `generated` buckets carry no foreign findings by construction. */
-function partitionFindings(findings, plan) {
-	const origins = new Map(plan.artifacts.map((artifact) => [artifact.path, artifact.origin]));
-	let ownedDrifted = 0;
-	let ownedMissing = 0;
-	let generatedDrifted = 0;
-	let generatedMissing = 0;
-	let foreign = 0;
-	for (const finding of findings) {
-		const origin = origins.get(finding.path);
-		const owned = origin === "host" || origin === "template";
-		if (finding.drift === "aligned") continue;
-		if (finding.drift === "foreign") {
-			foreign += 1;
-			continue;
-		}
-		if (finding.drift === "stale") {
-			if (owned) ownedDrifted += 1;
-			else generatedDrifted += 1;
-		} else if (finding.drift === "missing") {
-			if (owned) ownedMissing += 1;
-			else generatedMissing += 1;
-		}
-	}
-	return {
-		owned: {
-			drifted: ownedDrifted,
-			missing: ownedMissing,
-			foreign: 0
-		},
-		generated: {
-			drifted: generatedDrifted,
-			missing: generatedMissing,
-			foreign: 0
-		},
-		foreign: {
-			drifted: 0,
-			missing: 0,
-			foreign
-		}
-	};
-}
-/** Create one deterministic fleet result entry. */
-function fleetEntryOf(name, counts, failed, outside = 0) {
-	return {
-		name,
-		drifted: counts?.drifted ?? 0,
-		missing: counts?.missing ?? 0,
-		foreign: counts?.foreign ?? 0,
-		failed,
-		outside
-	};
-}
-/** Create the command-line interface's machine-readable failure envelope. */
-function errorEnvelopeOf(code, message) {
-	return { error: {
-		code,
-		message
-	} };
-}
-/** Project a plan summary to the stable machine-readable `new` result. */
-function summaryToNewResult(summary, applied) {
-	return {
-		name: summary.name,
-		src: summary.src,
-		app: summary.app,
-		host: summary.host,
-		template: summary.template,
-		computed: summary.computed,
-		applied
-	};
-}
-/** Add repair's outside-scope count to its selected audit. */
-function repairAuditOf(audit, outside) {
-	return {
-		...audit,
-		outside
-	};
-}
-/** Add a materialization result to a repair audit. */
-function auditToRepairResult(audit, result) {
-	return {
-		...audit,
-		result
-	};
-}
-/** Create the stable machine-readable catalog result. */
-function catalogResultOf(entries, drift, shrink) {
-	return shrink === void 0 ? {
-		entries,
-		drift
-	} : {
-		entries,
-		drift,
-		shrink
-	};
-}
-//#endregion
-//#region src/bin/helpers.ts
-/** Render one pluralized count. */
-function countPart(count, label) {
-	return `${count} ${label}${count === 1 ? "" : "s"}`;
-}
-/** Render nonzero audit buckets or `clean`. */
-function bucketText(counts) {
-	const parts = [];
-	if (counts.drifted > 0) parts.push(`${counts.drifted} drifted`);
-	if (counts.missing > 0) parts.push(`${counts.missing} missing`);
-	if (counts.foreign > 0) parts.push(`${counts.foreign} unexpected`);
-	return parts.length > 0 ? parts.join(", ") : "clean";
-}
-/** Render audit's origin-aware verdict. */
-function auditVerdict(audit, plan) {
-	const count = audit.findings.length;
-	if (audit.clean) return `audit: ${countPart(count, "artifact")} — clean`;
-	const split = partitionFindings(audit.findings, plan);
-	const owned = split.owned.drifted === 0 && split.owned.missing === 0;
-	const generated = bucketText(split.generated);
-	const foreign = bucketText(split.foreign);
-	if (owned && generated === "clean") return `audit: ${countPart(count, "artifact")} — host-owned clean; ${foreign}`;
-	const suffix = foreign === "clean" ? "" : `; unexpected: ${foreign}`;
-	return owned ? `audit: ${countPart(count, "artifact")} — host-owned clean; ${generated} (generated)${suffix}` : `audit: ${countPart(count, "artifact")} — host-owned: ${bucketText(split.owned)}; generated: ${generated}${suffix}`;
-}
-/** Render non-aligned audit findings as terminal table rows. */
-function findingRows(findings, plan) {
-	const origins = new Map(plan.artifacts.map((artifact) => [artifact.path, artifact.origin]));
-	return findings.filter((finding) => finding.drift !== "aligned").map((finding) => {
-		const origin = origins.get(finding.path);
-		const category = origin === void 0 ? "unexpected file" : ORIGIN_LABEL[origin];
-		return [
-			DRIFT_LABEL[finding.drift],
-			category,
-			finding.path
-		];
-	});
-}
-/** Create audit's terminal table. */
-function auditTable(audit, plan) {
-	return {
-		columns: [
-			{ label: "Status" },
-			{ label: "Kind" },
-			{ label: "Path" }
-		],
-		rows: findingRows(audit.findings, plan)
-	};
-}
-/**
-* Count the files one authorized write will create or overwrite.
-*
-* @param counts - The drift tallies of every target the write covers.
-* @param replace - Whether stale byte replacement was explicitly authorized.
-* @returns Every missing file, plus drifted files only under `replace`.
-* @remarks
-* The one figure every write confirmation asks about, so `repair` and `fleet`
-* cannot drift apart on it. An unexpected file is never counted here: only
-* `--prune` deletes one, and only after its own separate question.
-*/
-function countWrites(counts, replace) {
-	let total = 0;
-	for (const count of counts) total += count.missing + (replace ? count.drifted : 0);
-	return total;
-}
-/**
-* Test whether a reported repository remains dirty inside or outside the selected scope.
-*
-* @param audit - The selected-scope audit.
-* @param outside - Findings outside that scope.
-* @returns Whether either source reports drift.
-*/
-function hasFindings(audit, outside) {
-	return !audit.clean || outside > 0;
-}
-/**
-* Render one write verb's ownership boundary in that verb's own voice.
-*
-* @param verb - The command whose scope this is.
-* @param generated - Whether generated canon was included in the scope.
-* @param repos - The number of repositories the write covers, absent for a single target.
-* @returns The scope line naming what the command restores, what it replaces only with `--replace`, and what it never touches.
-*/
-function scopeLine(verb, generated, repos) {
-	return `${verb} scope${repos === void 0 ? "" : ` across ${countPart(repos, "repo")}`}: ${generated ? REPAIR_GENERATED_SCOPE : REPAIR_SCOPE}`;
-}
-/**
-* Render drift outside repair's selected ownership boundary.
-*
-* @param count - The number of findings outside the selected scope.
-* @param generated - Whether generated canon was included in the repair scope.
-* @returns The scope guidance line, or `undefined` when no findings remain outside scope.
-*/
-function scopeNote(count, generated) {
-	if (count === 0) return void 0;
-	return generated ? `note: ${countPart(count, "finding")} outside host-owned and generated repair scope — run 'audit' for the list; present starter files and package publication metadata remain protected` : `note: ${countPart(count, "finding")} outside host-owned repair scope — run 'audit' for the list`;
-}
-/**
-* Render repair's dry-run verdict.
-*
-* @param audit - The audit over the selected repair plan.
-* @param options - The selected scope and write authorizations.
-* @returns The scope-aware clean or drifted verdict.
-*/
-function repairVerdict(audit, options) {
-	const scope = options.generated ? "host-owned and generated" : "host-owned";
-	if (audit.clean) return `repair: ${countPart(audit.findings.length, `${scope} artifact`)} aligned — nothing to write`;
-	const head = `repair: ${scope}: ${bucketText(audit)}`;
-	if (audit.drifted === 0) return options.apply ? `${head} — missing files will be restored` : `${head} — pass --apply to write`;
-	if (audit.missing === 0) return options.replace ? `${head} — --apply overwrites drifted files, discarding local changes` : `${head} — drifted files change only with --replace, which discards local changes`;
-	return options.replace ? `${head} — --apply restores missing files and overwrites drifted ones, discarding local changes` : `${head} — --apply restores missing files; drifted files change only with --replace, which discards local changes`;
-}
-/**
-* Merge only generated service scripts into an existing manifest.
-*
-* @param current - The existing consumer manifest text.
-* @param generated - The canonical manifest text for the derived service blueprint.
-* @param services - The declared service vendor names.
-* @returns Formatter-stable manifest text preserving publication metadata and unrelated scripts.
-*/
-function mergeServiceManifest(current, generated, services) {
-	const currentManifest = parseJSON(current);
-	const generatedManifest = parseJSON(generated);
-	if (!isRecord(currentManifest) || !isRecord(generatedManifest)) throw new ScaffoldError("INVALID", "Service adoption requires object package manifests");
-	const currentScriptsValue = ownDataValue(currentManifest, "scripts");
-	const generatedScriptsValue = ownDataValue(generatedManifest, "scripts");
-	if (!isRecord(currentScriptsValue) || !isRecord(generatedScriptsValue)) throw new ScaffoldError("INVALID", "Service adoption requires object package scripts");
-	const serviceKeys = ["test:service", ...services.map((service) => `test:service:${service}`)];
-	const serviceNames = new Set(serviceKeys);
-	const currentPublish = ownDataValue(currentScriptsValue, "prepublishOnly");
-	const generatedPublish = ownDataValue(generatedScriptsValue, "prepublishOnly");
-	if (typeof currentPublish !== "string" || typeof generatedPublish !== "string") throw new ScaffoldError("INVALID", "Service adoption requires a prepublishOnly script");
-	const suffix = " && npm run test:service";
-	const publish = currentPublish.endsWith(suffix) ? currentPublish : `${currentPublish}${suffix}`;
-	const scripts = {};
-	for (const name of Object.keys(generatedScriptsValue)) {
-		if (serviceNames.has(name)) {
-			const value = ownDataValue(generatedScriptsValue, name);
-			if (typeof value !== "string") throw new ScaffoldError("INVALID", `Generated service script is missing at ${name}`);
-			scripts[name] = value;
-			continue;
-		}
-		if (name === "prepublishOnly") {
-			scripts[name] = publish;
-			continue;
-		}
-		const value = ownDataValue(currentScriptsValue, name);
-		if (value !== void 0) scripts[name] = value;
-	}
-	for (const name of Object.keys(currentScriptsValue)) {
-		if (Object.hasOwn(scripts, name)) continue;
-		if (name === "test:service" || name.startsWith("test:service:")) continue;
-		const value = ownDataValue(currentScriptsValue, name);
-		if (value !== void 0) scripts[name] = value;
-	}
-	return `${JSON.stringify({
-		...currentManifest,
-		scripts
-	}, void 0, "	")}\n`;
-}
-/**
-* Render repair's closing tally.
-*
-* @param tally - The displayed counts of one repair run.
-* @returns The tally line, in the same words the audit table above it used.
-* @remarks
-* A drifted file repair was not authorized to overwrite is counted on its own
-* rather than folded in with the aligned files, because `unchanged` is already
-* the audit table's word for a file that matches canon.
-*/
-function repairTally(tally) {
-	const left = tally.drifted === 0 ? "" : `, ${countPart(tally.drifted, `${DRIFT_LABEL.stale} file`)} left alone`;
-	return `${ACTION_LABEL.written} ${tally.written}, ${ACTION_LABEL.skipped} ${tally.unchanged}${left}, ${ACTION_LABEL.removed} ${tally.removed}`;
-}
-/** Render synchronization freshness as table rows. */
-function syncRows(report) {
-	const guides = report.guides.map((guide) => [
-		guide.name,
-		"guide",
-		FRESHNESS_LABEL[guide.freshness] ?? guide.freshness
-	]);
-	const versions = report.versions.map((version) => [
-		version.name,
-		"version",
-		FRESHNESS_LABEL[version.freshness] ?? version.freshness
-	]);
-	return [...guides, ...versions];
-}
-/** Create a synchronization terminal table. */
-function syncTable(report) {
-	return {
-		columns: [
-			{ label: "Name" },
-			{ label: "Kind" },
-			{ label: "Freshness" }
-		],
-		rows: syncRows(report)
-	};
-}
-/** Render cause notes from non-current synchronization entries. */
-function syncCauseNotes(report) {
-	return [...report.guides, ...report.versions].filter((entry) => entry.note !== void 0).map((entry) => `  ${entry.name}: ${FRESHNESS_LABEL[entry.freshness] ?? entry.freshness} — ${entry.note}`);
-}
-/** Render a command-specific synchronization tally. */
-function syncVerdict(report, action) {
-	const count = report.guides.length + report.versions.length;
-	return `${action}: ${String(count)} ${count === 1 ? "entry" : "entries"} — ${String(report.failed)} failed`;
-}
-/** Render a synchronization success tally. */
-function syncSuccess(count) {
-	return `wrote ${countPart(count, "guide")}`;
-}
-/** Render one fleet repository outcome. */
-function fleetRepoLine(name, outcome) {
-	if (outcome.state === "clean") return `${name}: clean`;
-	if (outcome.state === "drifted") return `${name}: ${bucketText(outcome)}`;
-	if (outcome.state === "repaired") return `${name}: repaired (${countPart(outcome.remaining, "finding")} remaining)`;
-	return `${name}: ${outcome.message}`;
-}
-/** Render fleet's repository totals. */
-function fleetTotals(drifted, failed) {
-	return `total: ${countPart(drifted, "dirty repo")}, ${failed} failed`;
-}
-/** Create catalog's terminal table. */
-function catalogTable(entries) {
-	return {
-		columns: [{ label: "Package" }, { label: "Version" }],
-		rows: entries.map((entry) => [entry.name, entry.version])
-	};
-}
-/** Render catalog shrink risk when present. */
-function catalogShrinkWarning(oldRows, newRows) {
-	if (newRows >= oldRows) return void 0;
-	return `warning: catalog shrinks from ${countPart(oldRows, "row")} to ${newRows}`;
-}
-/** Render catalog source tallies. */
-function catalogCounts(published, local) {
-	return `catalog: ${countPart(published, "published package")}, ${countPart(local, "local-only")}`;
-}
-/** Create `new`'s plan summary table. */
-function newPlanTable(summary) {
-	return {
-		columns: [{ label: "Origin" }, {
-			label: "Count",
-			align: "right"
-		}],
-		rows: [
-			["host-owned", String(summary.host)],
-			["starter", String(summary.template)],
-			["generated", String(summary.computed)]
-		]
-	};
-}
-/**
-* Render one contained write destination as the operator's own path to it.
-*
-* @param root - The invocation directory every write is confined beneath.
-* @param destination - The contained physical destination.
-* @returns The destination relative to the invocation directory, or the absolute path when it is not beneath it.
-*/
-function describeDestination(root, destination) {
-	const path = relative(root, destination).replaceAll("\\", "/");
-	if (path === "") return ".";
-	return path.startsWith("..") ? destination : `./${path}`;
-}
-/** Render `new`'s dry-run destination. */
-function newPlanPreview(destination) {
-	return `will write into ${destination}`;
-}
-/** Render `new`'s write result. */
-function newApplySuccess(count, destination) {
-	return `wrote ${countPart(count, "file")} into ${destination}`;
-}
-/** Render catalog's write result. */
-function catalogApplySuccess(path) {
-	return `wrote ${path}`;
-}
-/** Render the shared write confirmation. */
-function applyConfirmMessage(files, repos) {
-	const scope = repos === void 0 ? "" : ` across ${countPart(repos, "repo")}`;
-	return `Apply — write ${countPart(files, "file")}${scope}? `;
-}
-/** Render the separate prune confirmation. */
-function pruneConfirmMessage(count) {
-	return `Also delete ${countPart(count, "unexpected file")} under .claude/agents, .codex/agents, and scripts? `;
-}
-/**
-* Render the interactive audit-to-repair handoff as the list of actions it authorizes.
-*
-* @param missing - The number of missing host-owned files the inherited repair would restore.
-* @param drifted - The number of drifted host-owned files it would overwrite, zero unless `--replace` authorized replacement.
-* @param foreign - The number of unexpected files found.
-* @param prune - Whether `--prune` authorized deletion, without which no unexpected file is touched.
-* @returns The confirmation question, naming each authorized action and the cost of overwriting.
-*/
-function repairHandoff(missing, drifted, foreign, prune) {
-	const parts = [];
-	if (missing > 0) parts.push(`restore ${countPart(missing, "missing host-owned file")}`);
-	if (drifted > 0) parts.push(`overwrite ${countPart(drifted, "drifted host-owned file")}, discarding local changes`);
-	if (prune && foreign > 0) parts.push(`delete ${countPart(foreign, "unexpected file")}`);
-	return `${parts.join("; ")} — run repair now? `;
-}
-/** Render one unresolved Orkestrel dependency token. */
-function unknownOrkestrelToken(token, suggestion) {
-	const message = `"${token}" is not a published @orkestrel package`;
-	return suggestion === void 0 ? `${message} — try again` : `${message} — did you mean "${suggestion}"? try again`;
-}
-/** Render compact command usage. */
-function shortUsage() {
-	return [
-		"scaffold <verb> [options]",
-		"",
-		...KNOWN_VERBS.map((verb) => `  ${verb.padEnd(8)}${VERB_SUMMARY[verb]}`),
-		"",
-		"run 'scaffold <verb> --help' for a verb's full reference"
-	].join("\n");
-}
-/** Render the full command reference. */
-function fullHelp() {
-	const verbs = KNOWN_VERBS.map((verb) => `  ${verb} ${VERB_FLAGS[verb]}\n    ${VERB_SUMMARY[verb]}`);
-	const exits = EXIT_CODES.map(([code, meaning]) => `  ${code}  ${meaning}`);
-	return [
-		"scaffold <verb> [options]",
-		"",
-		...verbs,
-		"",
-		SAFETY_BANNER,
-		"",
-		"exit codes:",
-		...exits
-	].join("\n");
-}
-/** Render one command's help reference. */
-function verbHelp(verb) {
-	const flags = VERB_FLAG_HELP[verb].map(([flag, meaning]) => `  ${flag.padEnd(20)}${meaning}`);
-	return [
-		`scaffold ${verb} ${VERB_FLAGS[verb]}`,
-		"",
-		VERB_SUMMARY[verb],
-		VERB_DRY_RUN_NOTE[verb],
-		"",
-		...flags,
-		"",
-		VERB_EXAMPLE[verb]
-	].join("\n");
-}
-/** Compute Levenshtein edit distance. */
-function editDistance(left, right) {
-	const rows = left.length + 1;
-	const columns = right.length + 1;
-	const table = new Uint32Array(rows * columns);
-	for (let row = 0; row < rows; row += 1) table[row * columns] = row;
-	for (let column = 0; column < columns; column += 1) table[column] = column;
-	for (let row = 1; row < rows; row += 1) for (let column = 1; column < columns; column += 1) {
-		const cost = left[row - 1] === right[column - 1] ? 0 : 1;
-		const index = row * columns + column;
-		table[index] = Math.min((table[index - columns] ?? 0) + 1, (table[index - 1] ?? 0) + 1, (table[index - columns - 1] ?? 0) + cost);
-	}
-	return table[rows * columns - 1] ?? 0;
-}
-/** Find the nearest string by edit distance. */
-function nearest(input, set) {
-	let best;
-	let distance = Number.POSITIVE_INFINITY;
-	for (const candidate of set) {
-		const candidateDistance = editDistance(input, candidate);
-		if (candidateDistance < distance) {
-			distance = candidateDistance;
-			best = candidate;
-		}
-	}
-	return best;
-}
-/** Render an unknown command with a nearest-command hint. */
-function didYouMean(command) {
-	const suggestion = nearest(command, KNOWN_VERBS);
-	return suggestion === void 0 ? `unknown command "${command}"` : `unknown command "${command}" — did you mean "${suggestion}"?`;
-}
-/** Render one prune preview line per exact path. */
-function prunePreview(paths) {
-	return paths.map((path) => `  delete ${path}`);
-}
-/** Render non-terminal guidance for missing input. */
-function missingInput(input, verb) {
-	return `missing ${input} — pass it as a flag/argument, or run 'scaffold ${verb}' on a terminal to be guided`;
-}
-/** Render an invalid package name. */
-function invalidName(name, pattern) {
-	return `Package name "${name}" must match ${pattern}`;
-}
-/** Render dependencies whose latest versions could not be resolved. */
-function unresolvedVersion(names) {
-	return `could not resolve the latest version for ${names.map((name) => `"${name}"`).join(", ")} — check the name or pass name@range`;
-}
-/**
-* Render drift that belongs to generated artifacts.
-*
-* @param count - The number of findings on generated artifacts.
-* @returns The guidance line, stating what each repair scope does rather than how the files differ.
-*/
-function generatedNote(count) {
-	return `${countPart(count, "finding")} in generated files — run 'scaffold repair --generated' to restore missing ones; add --replace to overwrite drifted ones, discarding local changes`;
-}
-/**
-* Render the explicit destructive opt-in for stale host-owned files.
-*
-* @param count - The number of stale host-owned files.
-* @returns The replacement guidance line, naming the safe default before its destructive opt-in.
-*/
-function replacementNote(count) {
-	return `${countPart(count, "drifted host-owned file")} — repair leaves drifted files alone; 'scaffold repair --replace' overwrites them, discarding local changes`;
-}
-/**
-* Render honest repair guidance for computed and protected manifest drift.
-*
-* @param findings - The audit findings to classify.
-* @param plan - The plan that owns each computed artifact.
-* @returns One line for repairable computed drift and one for protected manifest drift when present.
-*/
-function renderComputedNotes(findings, plan) {
-	const origins = new Map(plan.artifacts.map((artifact) => [artifact.path, artifact.origin]));
-	let computed = 0;
-	let manifest = 0;
-	for (const finding of findings) {
-		if (finding.drift === "aligned" || origins.get(finding.path) !== "computed") continue;
-		if (finding.path === "package.json") manifest += 1;
-		else computed += 1;
-	}
-	const notes = [];
-	if (computed > 0) notes.push(generatedNote(computed));
-	if (manifest > 0 && plan.blueprint.services.length > 0) notes.push(`${countPart(manifest, "finding")} in package.json — 'scaffold repair --generated' repairs generated service scripts; review any remaining publication metadata directly`);
-	else if (manifest > 0) notes.push(`${countPart(manifest, "finding")} in package.json — repair does not rewrite protected publication metadata; review and edit it directly`);
-	return notes;
-}
-/** Render live dependency freshness tallies. */
-function auditLiveNote(current, behind, failed) {
-	return `live: ${current} current, ${behind} behind, ${failed} failed`;
-}
-/** Render whether an audit compared content or presence. */
-function comparisonLine(compared, presence) {
-	if (presence === 0) return "comparing: file contents for host-owned files";
-	if (compared === 0) return `comparing: file presence for ${countPart(presence, "presence-owned file")}`;
-	return `comparing: file contents for ${countPart(compared, "host-owned file")}; presence for ${countPart(presence, "presence-owned file")}`;
-}
-/** Render catalog's final verdict. */
-function catalogVerdict(clean) {
-	return clean ? "catalog: clean" : "catalog: drifted — pass --apply to write";
-}
-/** Render a caught error without leaking implementation detail. */
-function describeError(error) {
-	if (isScaffoldError(error)) return `[${error.code}] ${error.message}`;
-	return error instanceof Error ? error.message : "unknown error";
-}
-/** Resolve and confine one write destination to its invocation root. */
-function containDestination(root, candidate) {
-	if (!isFilesystemPath(root) || !isFilesystemPath(candidate)) throw new ScaffoldError("INVALID", "Target paths must not contain control characters");
-	const contained = attempt(() => resolvePhysicalPath(root, candidate, "INVALID", "working directory"));
-	if (contained.success) return contained.value;
-	if (isScaffoldError(contained.error) && contained.error.code === "INVALID") throw new ScaffoldError("INVALID", `Target "${candidate}" is outside or traverses a linked parent of the working directory — run scaffold from the physical directory you want to write beneath.`, { path: candidate });
-	throw contained.error;
-}
-/** Return one dependency-token issue, or absence when it is valid. */
-function orkestrelTokenIssue(normalized, catalog) {
-	if (catalog === void 0) return DEPENDENCY_NAME_PATTERN.test(normalized) ? void 0 : unknownOrkestrelToken(normalized, void 0);
-	if (catalog.includes(normalized)) return void 0;
-	return unknownOrkestrelToken(normalized, nearest(normalized, catalog));
-}
-//#endregion
-//#region src/bin/parsers.ts
-/** Parse a strict command-line argument vector. */
-function parseArguments(argv) {
-	if (argv.some((argument) => !isTerminalText(argument))) throw new ScaffoldError("INVALID", "Command arguments must not contain control characters");
-	const args = argv[0] === "--" ? argv.slice(1) : [...argv];
-	return parseArgs({
-		args,
-		allowPositionals: true,
-		options: {
-			src: { type: "string" },
-			app: { type: "string" },
-			deps: { type: "string" },
-			groups: { type: "string" },
-			target: { type: "string" },
-			from: {
-				type: "string",
-				multiple: true
-			},
-			apply: {
-				type: "boolean",
-				default: false
-			},
-			yes: {
-				type: "boolean",
-				default: false
-			},
-			json: {
-				type: "boolean",
-				default: false
-			},
-			prune: {
-				type: "boolean",
-				default: false
-			},
-			generated: {
-				type: "boolean",
-				default: false
-			},
-			replace: {
-				type: "boolean",
-				default: false
-			},
-			strict: {
-				type: "boolean",
-				default: false
-			},
-			live: {
-				type: "boolean",
-				default: false
-			},
-			offline: {
-				type: "boolean",
-				default: false
-			},
-			help: {
-				type: "boolean",
-				default: false,
-				short: "h"
-			}
-		}
-	});
-}
-/** Split a comma-separated token list, trimming and dropping empty entries. */
-function splitTokens(raw) {
-	return raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
-}
-/** Normalize an Orkestrel dependency token to its full package name. */
-function normalizeOrkestrelToken(token) {
-	return token.startsWith("@orkestrel/") ? token : `@orkestrel/${token}`;
-}
-/**
-* Parse and resolve a pull dependency selection against the target manifest.
-*
-* @param raw - The comma-separated full package names, or `undefined` for all.
-* @param declared - The target's declared Orkestrel dependencies.
-* @returns `undefined` for all dependencies, otherwise the exact selected records.
-* @throws `ScaffoldError('INVALID')` for empty, malformed, repeated, or undeclared names.
-*/
-function parsePullDependencies(raw, declared) {
-	if (raw === void 0) return void 0;
-	const names = raw.split(",").map((name) => name.trim());
-	if (names.length === 0 || names.some((name) => !DEPENDENCY_NAME_PATTERN.test(name)) || new Set(names).size !== names.length) throw new ScaffoldError("INVALID", "Pull dependencies must be unique, comma-separated @orkestrel/* package names");
-	const selected = declared.filter((dependency) => names.includes(dependency.name));
-	const found = new Set(selected.map((dependency) => dependency.name));
-	const missing = names.filter((name) => !found.has(name));
-	if (missing.length > 0) throw new ScaffoldError("INVALID", `Pull dependencies are not declared by the target: ${missing.join(", ")}`, { dependencies: missing });
-	return selected;
-}
-//#endregion
-//#region src/bin/validators.ts
-/** Narrow a positional command to the command-line interface's vocabulary. */
-function isVerb(value) {
-	return KNOWN_VERBS.some((verb) => verb === value);
-}
-//#endregion
-//#region src/bin/CLI.ts
-/** Stateful command-line orchestration and its process boundary. */
-var CLI = class {
-	#sync;
-	#sink = createServerSink();
-	#tty = process.stdout.isTTY === true;
-	#styler = createStyler({ enabled: process.env.NO_COLOR === void 0 && this.#tty });
-	#reporter = createReporter({
-		sink: this.#sink,
-		width: this.#sink.columns,
-		styler: this.#styler
-	});
-	#json = false;
-	/**
-	* Create command-line orchestration with optional upstream endpoint settings.
-	*
-	* @param sync - Sync settings used by every live dependency operation.
-	*/
-	constructor(sync) {
-		this.#sync = parseSyncOptions(sync);
-	}
-	/** Execute one command-line argument vector. */
-	async run(argv) {
-		this.#trust();
-		try {
-			await this.#dispatch(argv);
-		} catch (error) {
-			if (error instanceof CLIExitError) process.exitCode = error.code;
-			else if (this.#json) {
-				const code = isScaffoldError(error) ? error.code : "ERROR";
-				const message = isScaffoldError(error) ? error.message : describeError(error);
-				this.#write(errorEnvelopeOf(code, message));
-				process.exitCode = 1;
-			} else {
-				this.#reporter.status("error", describeError(error));
-				process.exitCode = 1;
-			}
-		}
-	}
-	/**
-	* Widen Node's default trusted-issuer set to include the OS certificate
-	* store, so `fetch` behind a corporate TLS-inspecting proxy behaves like npm
-	* (`cafile`) and browsers (OS trust store) instead of failing with
-	* `UNABLE_TO_GET_ISSUER_CERT_LOCALLY` against Node's bundled CA list alone.
-	* Feature-detected (`tls.getCACertificates` / `tls.setDefaultCACertificates`
-	* ship on Node ≈22.16+/24.5+; this package's floor is `>=22.12.0`) and captured
-	* through `attempt` — any failure is a silent no-op, never a crash. This only ADDS
-	* trusted issuers; it never touches `rejectUnauthorized` or
-	* `NODE_TLS_REJECT_UNAUTHORIZED`, so certificate verification stays on.
-	*/
-	#trust() {
-		if (typeof tls.getCACertificates !== "function" || typeof tls.setDefaultCACertificates !== "function") return;
-		attempt(() => {
-			const merged = /* @__PURE__ */ new Set([...tls.getCACertificates("default"), ...tls.getCACertificates("system")]);
-			tls.setDefaultCACertificates([...merged]);
-		});
-	}
-	/** Write ONE machine-readable JSON value to stdout — the entire `--json` output contract. */
-	#write(value) {
-		process.stdout.write(`${JSON.stringify(value)}\n`);
-	}
-	/** Report a general operation failure with exit 1 as prose or one JSON error envelope. */
-	#fail(message, json) {
-		if (json) this.#write(errorEnvelopeOf("ERROR", message));
-		else this.#reporter.status("error", message);
-		throw new CLIExitError(1);
-	}
-	/**
-	* A general operation failure from a caught error — the real
-	* `ScaffoldError` code when available ('ERROR' last resort), prose (via
-	* `describe`, which still carries the bracketed code for a human reader) or
-	* the one JSON error envelope under `--json` (code and message kept
-	* SEPARATE — never double-encoding the code into the message text).
-	*/
-	#error(error, json) {
-		if (json) {
-			const code = isScaffoldError(error) ? error.code : "ERROR";
-			const message = isScaffoldError(error) ? error.message : describeError(error);
-			this.#write(errorEnvelopeOf(code, message));
-		} else this.#reporter.status("error", describeError(error));
-		throw new CLIExitError(1);
-	}
-	/** A usage error (bad flag value, unknown verb — exit 2) — stderr prose, or the one JSON error envelope under `--json`. */
-	#usage(message, json) {
-		if (json) this.#write(errorEnvelopeOf("USAGE", message));
-		else process.stderr.write(`${message}\n`);
-		throw new CLIExitError(2);
-	}
-	/** Contain a destination and report any coded escape through the shared CLI error path. */
-	#contain(candidate, json) {
-		const contained = attempt(() => containDestination(process.cwd(), candidate));
-		if (contained.success) return contained.value;
-		this.#error(contained.error, json);
-	}
-	/** Compile a spec and report unresolved blocking questions through the shared CLI error path. */
-	#compile(spec, json, groups) {
-		const compiler = createCompiler();
-		try {
-			const scaffolding = compiler.compile(spec, groups);
-			if (!scaffolding.plan) {
-				const blocking = scaffolding.questions.filter((question) => question.blocking);
-				const message = (blocking.length > 0 ? blocking : scaffolding.questions).map((question) => question.text).join("; ");
-				this.#fail(message, json);
-			}
-			return [scaffolding.plan, scaffolding.questions];
-		} finally {
-			compiler.destroy();
-		}
-	}
-	#prunePaths(target, host, services) {
-		const seam = services.length > 0 ? SERVICE_SCRIPT_PATH : void 0;
-		return pruneTargets(target, host).filter((path) => path !== seam);
-	}
-	/**
-	* Merge the physical prune scan into `audit` as `foreign` findings — pure
-	* object-spread composition in the BIN only (`src/core`'s `diffPlan` is never
-	* modified/reimplemented). Every unexpected path except the declared service
-	* workspace's exact `SERVICE_SCRIPT_PATH` becomes one `'orchestration'`-group
-	* `foreign` finding (the `Group` every `PRUNE_DIRECTORIES` entry—`.claude/agents`,
-	* `.codex/agents`, `scripts`—belongs to); any scan hit makes the merged audit
-	* unclean, so an "unexpected file" is honestly counted as drift (exit 1)
-	* instead of the structurally-always-zero `diffPlan.foreign`.
-	*/
-	#scan(audit, target, host, services) {
-		const paths = this.#prunePaths(target, host, services);
-		if (paths.length === 0) return audit;
-		const findings = paths.map((path) => ({
-			path,
-			group: "orchestration",
-			drift: "foreign"
-		}));
-		return {
-			...audit,
-			clean: false,
-			foreign: audit.foreign + paths.length,
-			findings: [...audit.findings, ...findings]
-		};
-	}
-	/**
-	* Add unexpected-file findings when the vendored allowlist can be established.
-	* When fail-closed allowlist discovery raises a coded `TARGET` failure, retain
-	* the existing findings and mark the audit incomplete instead of crashing.
-	*/
-	#scanSafe(audit, target, host, services) {
-		const scanned = attempt(() => this.#scan(audit, target, host, services));
-		if (scanned.success) return {
-			audit: scanned.value,
-			skipped: false
-		};
-		if (isScaffoldError(scanned.error) && scanned.error.code === "TARGET") return {
-			audit: {
-				...audit,
-				clean: false,
-				complete: false,
-				questions: [...audit.questions, {
-					field: "host",
-					text: scanned.error.message,
-					blocking: true
-				}]
-			},
-			skipped: true
-		};
-		throw scanned.error;
-	}
-	/**
-	* `repair` scopes to host-owned artifacts by default and optionally generated canon, but the
-	* caller compiles the full plan anyway. Diff it too so a clean scoped verdict can point at drift
-	* outside the selected boundary. The count feeds the shared `scopeNote` renderer.
-	*/
-	#outside(compiled, selected, target, host) {
-		const full = hydratePlan(compiled, host);
-		const selectedPaths = new Set(selected.artifacts.map((artifact) => artifact.path));
-		return diffPlan(full, readTarget(target, full.artifacts.map((artifact) => artifact.path))).findings.filter((finding) => finding.drift !== "aligned" && !selectedPaths.has(finding.path)).length;
-	}
-	#emitRepair(audit, generated, json, result) {
-		if (json) {
-			this.#write(result === void 0 ? audit : auditToRepairResult(audit, result));
-			return;
-		}
-		const note = scopeNote(audit.outside, generated);
-		if (note !== void 0) this.#reporter.line(note);
-	}
-	/** Promote only absent service-owned starter seams into repairable missing artifacts. */
-	#promoteServices(plan, target) {
-		if (plan.blueprint.services.length === 0) return plan;
-		const paths = [SERVICE_SCRIPT_PATH, "tests/config/services.test.ts"];
-		const current = readTarget(target, paths);
-		return {
-			...plan,
-			artifacts: plan.artifacts.map((artifact) => artifact.origin === "template" && paths.includes(artifact.path) && !Object.hasOwn(current, artifact.path) ? {
-				...artifact,
-				origin: "computed"
-			} : artifact)
-		};
-	}
-	/** Select repair ownership and merge only the manifest's generated service-script keys. */
-	#scopeRepair(compiled, target, generated) {
-		const promoted = this.#promoteServices(compiled, target);
-		const currentManifest = generated && promoted.blueprint.services.length > 0 ? readManifest(target) : void 0;
-		const artifacts = [];
-		for (const artifact of promoted.artifacts) {
-			if (artifact.origin === "host" || artifact.path === SERVICE_SCRIPT_PATH || artifact.path === "tests/config/services.test.ts" || generated && artifact.origin === "computed" && artifact.path !== "package.json") {
-				artifacts.push(artifact);
-				continue;
-			}
-			if (currentManifest !== void 0 && artifact.origin === "computed" && artifact.path === "package.json") {
-				const content = mergeServiceManifest(currentManifest, artifact.content, promoted.blueprint.services);
-				if (content !== currentManifest) artifacts.push({
-					...artifact,
-					content
-				});
-			}
-		}
-		return {
-			...promoted,
-			blueprint: {
-				...promoted.blueprint,
-				overrides: []
-			},
-			artifacts
-		};
-	}
-	/** Compile and audit the selected repair ownership boundary for one structural snapshot. */
-	#prepareRepair(spec, target, host, generated, json) {
-		const [compiled] = this.#compile(spec, json);
-		const scoped = this.#scopeRepair(compiled, target, generated);
-		let plan;
-		try {
-			plan = hydratePlan(scoped, host);
-		} catch (error) {
-			this.#error(error, json);
-		}
-		try {
-			const audit = diffPlan(plan, readTarget(target, plan.artifacts.map((artifact) => artifact.path)));
-			return [
-				compiled,
-				plan,
-				audit
-			];
-		} catch (error) {
-			this.#error(error, json);
-		}
-	}
-	/** Reject a cancelled prompt (ctrl-c) with the shared `CANCELLED_MESSAGE` — exit 1, nothing written. */
-	async #guard(promise) {
-		try {
-			return await promise;
-		} catch (error) {
-			if (isTerminalError(error) && error.code === "CANCEL") {
-				this.#reporter.line(CANCELLED_MESSAGE);
-				throw new CLIExitError(1);
-			}
-			throw error;
-		}
-	}
-	/**
-	* The shared write-confirmation gate every verb calls before it touches disk.
-	* `--apply` is the sole write authorization. JSON and non-terminal calls do
-	* not prompt once authorized; `--yes` skips the terminal confirmation.
-	*/
-	async #apply(terminal, message, values, json) {
-		if (!values.apply) return false;
-		if (json || values.yes || !this.#tty) return true;
-		return this.#guard(terminal.confirm({
-			message,
-			default: false
-		}));
-	}
-	/**
-	* The SECOND, separate confirm for `--prune`-eligible deletions — never
-	* bundled into the write question. Both `--prune` and `--apply` are required;
-	* `--yes` only skips this confirmation and never authorizes deletion.
-	*/
-	async #prune(terminal, message, values, json) {
-		if (!values.prune) return false;
-		if (!values.apply) {
-			if (!json && !this.#tty) this.#reporter.line(PRUNE_SKIPPED);
-			return false;
-		}
-		if (json || values.yes || !this.#tty) return true;
-		return this.#guard(terminal.confirm({
-			message,
-			default: false
-		}));
-	}
-	/** A spinner for a long-running write step, absent under `--json` or off a TTY sink. */
-	#spinner(message, json) {
-		return json || !this.#tty ? void 0 : createSpinner({
-			message,
-			sink: this.#sink,
-			styler: this.#styler
-		});
-	}
-	/** Announce a successful write — the spinner's own success line, or a plain `reporter.status` without one (never under `--json`). */
-	#succeed(spinner, json, message) {
-		if (spinner) spinner.success(message);
-		else if (!json) this.#reporter.status("success", message);
-	}
-	/** Announce a failed write and halt(1) — the spinner's own failure line (if any), then the shared `fail`. */
-	#reject(spinner, json, error) {
-		const message = describeError(error);
-		if (spinner) spinner.failure(message);
-		this.#fail(message, json);
-	}
-	/**
-	* Best-effort vendored `@orkestrel` catalog names, resolved via `host`
-	* (`hostRoot()`, or the active `--from` override) through the host manifest
-	* — `undefined` when the catalog cannot be established (a missing/unreadable
-	* manifest, no `CATALOG_AGENT_PATH` entry, or any other failure),
-	* degrading the dependency prompt to shape-only validation instead of blocking on it.
-	*/
-	#names(host) {
-		const names = attempt(() => {
-			const manifest = readHostManifest(host);
-			const full = locateHostSource(manifest, CATALOG_AGENT_PATH, host);
-			if (full === void 0 || !existsSync(full)) return void 0;
-			const relative$1 = relative(host, full).replaceAll("\\", "/");
-			return catalogNames(readFileText(host, relative$1, "TARGET", "host"));
-		});
-		return names.success ? names.value : void 0;
-	}
-	/** Prompt for `@orkestrel` short-name dependencies until every token resolves or input is empty. */
-	async #prompt(terminal, catalog) {
-		for (;;) {
-			const tokens = splitTokens(await this.#guard(terminal.input({
-				message: ORKESTREL_DEPS_PROMPT,
-				default: ""
-			})));
-			if (tokens.length === 0) return [];
-			const normalized = tokens.map(normalizeOrkestrelToken);
-			const issue = normalized.map((token) => orkestrelTokenIssue(token, catalog)).find((message) => message !== void 0);
-			if (issue === void 0) return normalized;
-			this.#reporter.line(issue);
-		}
-	}
-	/** `scaffold new` — scaffold a package into `./<name>` (or `--target`). */
-	async #new(values, argument, json) {
-		const terminal = createTerminal();
-		let name;
-		if (argument !== void 0) name = argument;
-		else if (json) this.#usage("a package name is required with --json", json);
-		else if (!this.#tty) this.#usage(missingInput("a package name", "new"), json);
-		else name = await this.#guard(terminal.input({
-			message: "Package name",
-			validate: { pattern: NAME_PATTERN.source }
-		}));
-		if (!NAME_PATTERN.test(name)) this.#usage(invalidName(name, NAME_PATTERN.source), json);
-		let srcInput;
-		let appInput;
-		if (values.src !== void 0) srcInput = values.src.split(",").map((candidate) => candidate.trim());
-		else if (values.app !== void 0) srcInput = [];
-		else if (json || !this.#tty) this.#usage("at least one of --src or --app is required", json);
-		else srcInput = await this.#guard(terminal.checkbox({
-			message: "Published src environments",
-			choices: ENVIRONMENT_CHOICES,
-			min: 0
-		}));
-		if (values.app !== void 0) appInput = values.app.split(",").map((candidate) => candidate.trim());
-		else if (values.src !== void 0 || json || !this.#tty) appInput = [];
-		else appInput = await this.#guard(terminal.checkbox({
-			message: "Application environments",
-			choices: ENVIRONMENT_CHOICES,
-			min: 0
-		}));
-		const unrecognizedSrcEnvironment = srcInput.filter((candidate) => !ENVIRONMENTS.some((environment) => environment === candidate));
-		if (unrecognizedSrcEnvironment.length > 0) this.#usage(`Environment "${unrecognizedSrcEnvironment.join("\", \"")}" is not recognized`, json);
-		if (new Set(srcInput).size !== srcInput.length) this.#usage("Published src environments must not repeat", json);
-		const src = ENVIRONMENTS.filter((environment) => srcInput.includes(environment));
-		const unrecognizedAppEnvironment = appInput.filter((candidate) => !ENVIRONMENTS.some((environment) => environment === candidate));
-		if (unrecognizedAppEnvironment.length > 0) this.#usage(`Application environment "${unrecognizedAppEnvironment.join("\", \"")}" is not recognized`, json);
-		if (new Set(appInput).size !== appInput.length) this.#usage("Application environments must not repeat", json);
-		const app = ENVIRONMENTS.filter((environment) => appInput.includes(environment));
-		if (src.length === 0 && app.length === 0) this.#usage("at least one source or application environment is required", json);
-		const destination = this.#contain(values.target ?? `./${name}`, json);
-		if (!isVacant(destination)) this.#error(new ScaffoldError("TARGET", "new requires a vacant target", { target: destination }), json);
-		const explicitHost = values.from?.[0];
-		if (explicitHost !== void 0) {
-			if (!isRealDirectory(explicitHost)) this.#error(new ScaffoldError("TARGET", `Host root is not a physical directory at ${explicitHost}`, { host: explicitHost }), json);
-			readHostManifest(explicitHost);
-		}
-		let depNames;
-		if (values.deps !== void 0) {
-			depNames = values.deps.split(",").filter((depName) => depName.length > 0);
-			const badDep = depNames.find((depName) => !DEPENDENCY_NAME_PATTERN.test(depName));
-			if (badDep !== void 0) this.#usage(`Dependency name "${badDep}" must match ${DEPENDENCY_NAME_PATTERN.source}`, json);
-		} else if (json || !this.#tty) depNames = [];
-		else {
-			const catalogHost = values.from?.[0] ?? hostRoot();
-			const catalog = this.#names(catalogHost);
-			if (catalog === void 0) this.#reporter.line(CATALOG_UNRESOLVED_NOTE);
-			depNames = await this.#prompt(terminal, catalog);
-		}
-		const sync = createSync(this.#sync);
-		let versions;
-		try {
-			versions = await sync.lookup(depNames);
-		} finally {
-			sync.destroy();
-		}
-		const unresolved = versions.filter((version) => version.freshness === "missing" || version.freshness === "failed").map((version) => version.name);
-		if (unresolved.length > 0) this.#fail(unresolvedVersion(unresolved), json);
-		const deps = versions.map((version) => {
-			if (version.freshness !== "behind") this.#fail(unresolvedVersion([version.name]), json);
-			return dependency(version.name, `^${version.latest}`);
-		});
-		const [plan] = this.#compile(blueprint(name, {
-			src,
-			app,
-			dependencies: deps
-		}), json);
-		const summary = planToSummary(plan);
-		const label = describeDestination(process.cwd(), destination);
-		if (!json) {
-			this.#reporter.section("Plan");
-			this.#reporter.table(newPlanTable(summary));
-			this.#reporter.line(newPlanPreview(label));
-		}
-		if (!await this.#apply(terminal, applyConfirmMessage(summary.host + summary.template + summary.computed), values, json)) {
-			if (json) this.#write(summaryToNewResult(summary, false));
-			else this.#reporter.line(NEW_DRY_RUN_NOTE);
-			process.exitCode = 0;
-			return;
-		}
-		const spinner = this.#spinner("materializing", json);
-		spinner?.start();
-		const host = values.from?.[0];
-		const materializer = createMaterializer(host === void 0 ? void 0 : { host });
-		try {
-			const result = materializer.materialize(plan, destination);
-			const count = result.written.length + result.copied.length;
-			if (json) this.#write(summaryToNewResult(summary, true));
-			else this.#succeed(spinner, json, newApplySuccess(count, label));
-		} catch (error) {
-			this.#reject(spinner, json, error);
-		} finally {
-			materializer.destroy();
-		}
-		process.exitCode = 0;
-	}
-	/** `scaffold pull` — refresh vendored dependency mirrors and report range drift. */
-	async #pull(values, json) {
-		const target = this.#contain(values.target ?? ".", json);
-		const sync = createSync(values.strict === void 0 ? this.#sync : {
-			...this.#sync,
-			strict: values.strict
-		});
-		try {
-			let report;
-			try {
-				const declared = manifestToDependencies(readManifest(target));
-				const selected = parsePullDependencies(values.deps, declared);
-				report = await sync.pull(target, selected);
-			} catch (error) {
-				this.#error(error, json);
-			}
-			await this.#refresh(sync, report, target, values, json, "pull", true);
-		} finally {
-			sync.destroy();
-		}
-	}
-	/** `scaffold mirror` — refresh every published Orkestrel package guide. */
-	async #mirror(values, json) {
-		const target = this.#contain(values.target ?? ".", json);
-		const sync = createSync(values.strict === void 0 ? this.#sync : {
-			...this.#sync,
-			strict: values.strict
-		});
-		try {
-			let report;
-			try {
-				report = await sync.mirror(target);
-			} catch (error) {
-				this.#error(error, json);
-			}
-			await this.#refresh(sync, report, target, values, json, "mirror", report.failed === 0);
-		} finally {
-			sync.destroy();
-		}
-	}
-	async #refresh(sync, report, target, values, json, action, writable) {
-		if (!json) {
-			this.#reporter.table(syncTable(report));
-			for (const line of syncCauseNotes(report)) this.#reporter.line(line);
-			this.#reporter.line(syncVerdict(report, action));
-		}
-		const toWrite = [...report.guides, ...report.versions].filter((entry) => entry.freshness !== "current").length;
-		const terminal = createTerminal();
-		const proceed = writable && toWrite > 0 ? await this.#apply(terminal, applyConfirmMessage(toWrite), values, json) : false;
-		if (proceed) {
-			const spinner = this.#spinner("writing mirrors", json);
-			spinner?.start();
-			try {
-				const written = await sync.write(report, target);
-				if (json) this.#write(report);
-				else this.#succeed(spinner, json, syncSuccess(written.length));
-			} catch (error) {
-				this.#reject(spinner, json, error);
-			}
-		} else if (json) this.#write(report);
-		process.exitCode = report.failed > 0 ? 1 : report.clean || proceed ? 0 : 1;
-	}
-	/** `scaffold audit` — whole-plan conformance report; offers a repair handoff on drift. */
-	async #audit(values, json) {
-		const target = this.#contain(values.target ?? ".", json);
-		let spec;
-		try {
-			spec = deriveBlueprint(target);
-		} catch (error) {
-			this.#error(error, json);
-		}
-		const deps = [
-			...spec.dependencies,
-			...spec.peers,
-			...spec.extras
-		];
-		const groupsInput = values.groups?.split(",");
-		let groups;
-		if (groupsInput !== void 0) {
-			const unrecognized = groupsInput.filter((name) => !GROUPS.some((group) => group === name));
-			if (unrecognized.length > 0) this.#usage(`Group "${unrecognized.join("\", \"")}" is not recognized`, json);
-			groups = GROUPS.filter((group) => groupsInput.includes(group));
-		}
-		const [compiled, questions] = this.#compile(spec, json, groups);
-		const host = values.from?.[0] ?? hostRoot();
-		let plan;
-		try {
-			plan = hydratePlan(this.#promoteServices(compiled, target), host);
-		} catch (error) {
-			this.#error(error, json);
-		}
-		const artifactPaths = plan.artifacts.map((artifact) => artifact.path);
-		const rawAudit = {
-			...diffPlan(plan, readTarget(target, artifactPaths)),
-			questions
-		};
-		const scanned = this.#scanSafe(rawAudit, target, host, spec.services);
-		const audit = scanned.audit;
-		let drifted = !audit.clean;
-		let live;
-		if (values.live) {
-			const sync = createSync(this.#sync);
-			try {
-				const manifestName = manifestToName(readManifest(target));
-				const guideDependencies = deps.filter((entry) => entry.name !== manifestName);
-				const guides = await sync.guides(guideDependencies);
-				const versions = await sync.versions(deps);
-				const entries = [...guides, ...versions];
-				drifted ||= entries.some((entry) => entry.freshness !== "current");
-				const current = entries.filter((entry) => entry.freshness === "current").length;
-				const behind = entries.filter((entry) => entry.freshness === "behind").length;
-				live = {
-					current,
-					behind,
-					failed: entries.length - current - behind
-				};
-			} finally {
-				sync.destroy();
-			}
-		}
-		if (json) {
-			this.#write(live === void 0 ? audit : {
-				...audit,
-				live
-			});
-			process.exitCode = drifted ? 1 : 0;
-			return;
-		}
-		if (scanned.skipped) this.#reporter.line(SCAN_SKIPPED);
-		for (const question of audit.questions) if (!question.blocking) this.#reporter.line(`warning: ${question.text}`);
-		const hostArtifacts = plan.artifacts.filter((artifact) => artifact.origin === "host");
-		const presenceOwned = hostArtifacts.filter((artifact) => artifact.hex === void 0).length;
-		this.#reporter.line(comparisonLine(hostArtifacts.length - presenceOwned, presenceOwned));
-		this.#reporter.table(auditTable(audit, plan));
-		this.#reporter.line(auditVerdict(audit, plan));
-		if (live !== void 0) this.#reporter.line(auditLiveNote(live.current, live.behind, live.failed));
-		if (!audit.clean) {
-			const split = partitionFindings(audit.findings, plan);
-			const replace = values.replace === true;
-			const ownedCount = split.owned.missing + (replace ? split.owned.drifted : 0);
-			const pruneRequested = values.prune === true;
-			const offerHandoff = this.#tty && (ownedCount > 0 || audit.foreign > 0 && pruneRequested);
-			let handoffAccepted = false;
-			if (offerHandoff) {
-				const terminal = createTerminal();
-				const message = repairHandoff(split.owned.missing, replace ? split.owned.drifted : 0, audit.foreign, pruneRequested);
-				handoffAccepted = await this.#guard(terminal.confirm({
-					message,
-					default: false
-				}));
-				if (handoffAccepted) {
-					await this.#repair(values, false);
-					const rawFinal = diffPlan(plan, readTarget(target, artifactPaths));
-					const finalScanned = this.#scanSafe(rawFinal, target, host, spec.services);
-					process.exitCode = finalScanned.audit.clean ? 0 : 1;
-					return;
-				}
-			}
-			if (!handoffAccepted) {
-				if (split.owned.drifted > 0 && !replace) this.#reporter.line(replacementNote(split.owned.drifted));
-				if (audit.foreign > 0 && !pruneRequested) this.#reporter.line(FOREIGN_HINT);
-				for (const note of renderComputedNotes(audit.findings, plan)) this.#reporter.line(note);
-			}
-		}
-		process.exitCode = drifted ? 1 : 0;
-	}
-	/** `scaffold repair` — restore host-owned files and optionally generated canon for one target. */
-	async #repair(values, json) {
-		const target = this.#contain(values.target ?? ".", json);
-		let spec;
-		try {
-			spec = deriveBlueprint(target);
-		} catch (error) {
-			this.#error(error, json);
-		}
-		const generated = values.generated === true;
-		const replace = values.replace === true;
-		const host = values.from?.[0] ?? hostRoot();
-		const prepared = this.#prepareRepair(spec, target, host, generated, json);
-		let compiled = prepared[0];
-		let plan = prepared[1];
-		let audit = prepared[2];
-		let outcome = repairAuditOf(this.#scanSafe(audit, target, host, spec.services).audit, this.#outside(compiled, plan, target, host));
-		const verdict = {
-			generated,
-			replace,
-			apply: values.apply === true
-		};
-		if (!json) {
-			if (!outcome.clean) this.#reporter.line(scopeLine("repair", generated));
-			this.#reporter.section("Audit");
-			this.#reporter.table(auditTable(outcome, plan));
-		}
-		const prunePaths = values.prune ? this.#prunePaths(target, host, spec.services) : [];
-		const pruneSnapshot = readTarget(target, prunePaths);
-		if (outcome.clean && prunePaths.length === 0) {
-			if (!json) this.#reporter.line(repairVerdict(outcome, verdict));
-			this.#emitRepair(outcome, generated, json);
-			process.exitCode = hasFindings(outcome, outcome.outside) ? 1 : 0;
-			return;
-		}
-		if (!json) this.#reporter.line(repairVerdict(outcome, verdict));
-		const repairable = countWrites([audit], replace);
-		if (repairable === 0 && prunePaths.length === 0) {
-			if (!json) this.#reporter.line(repairTally({
-				written: 0,
-				unchanged: audit.findings.length - audit.drifted - audit.missing - audit.foreign,
-				drifted: audit.drifted,
-				removed: 0
-			}));
-			this.#emitRepair(outcome, generated, json);
-			process.exitCode = 1;
-			return;
-		}
-		const terminal = createTerminal();
-		let proceed = true;
-		if (!audit.clean) proceed = await this.#apply(terminal, applyConfirmMessage(repairable), values, json);
-		if (!proceed) {
-			this.#emitRepair(outcome, generated, json);
-			process.exitCode = 1;
-			return;
-		}
-		if (values.prune && !json) {
-			if (prunePaths.length === 0) this.#reporter.line(PRUNE_EMPTY);
-			else for (const line of prunePreview(prunePaths)) this.#reporter.line(line);
-		}
-		const doPrune = prunePaths.length > 0 && await this.#prune(terminal, pruneConfirmMessage(prunePaths.length), values, json);
-		let currentGlobal;
-		try {
-			currentGlobal = deriveBlueprint(target).global;
-		} catch (error) {
-			this.#error(error, json);
-		}
-		if (currentGlobal !== spec.global) {
-			spec = {
-				...spec,
-				global: currentGlobal
-			};
-			const refreshed = this.#prepareRepair(spec, target, host, generated, json);
-			compiled = refreshed[0];
-			plan = refreshed[1];
-			audit = refreshed[2];
-			outcome = repairAuditOf(this.#scanSafe(audit, target, host, spec.services).audit, this.#outside(compiled, plan, target, host));
-		}
-		const spinner = this.#spinner("repairing", json);
-		spinner?.start();
-		const materializer = createMaterializer({ host });
-		try {
-			const result = materializer.repair(plan, audit, target, replace);
-			const removed = doPrune ? materializer.prune(target, pruneSnapshot).removed : [];
-			const finalAudit = repairAuditOf(this.#scanSafe(diffPlan(plan, readTarget(target, plan.artifacts.map((artifact) => artifact.path))), target, host, spec.services).audit, outcome.outside);
-			const left = replace ? 0 : audit.drifted;
-			if (!json) this.#succeed(spinner, json, repairTally({
-				written: result.written.length + result.copied.length,
-				unchanged: result.skipped.length - left,
-				drifted: left,
-				removed: removed.length
-			}));
-			this.#emitRepair(finalAudit, generated, json, {
-				...result,
-				removed
-			});
-			process.exitCode = hasFindings(finalAudit, finalAudit.outside) ? 1 : 0;
-		} catch (error) {
-			this.#reject(spinner, json, error);
-		} finally {
-			materializer.destroy();
-		}
-	}
-	/** `scaffold fleet` — audit/repair every `@orkestrel` package beneath the current directory's immediate children. */
-	async #fleet(values, json) {
-		const root = this.#contain(".", json);
-		const generated = values.generated === true;
-		const replace = values.replace === true;
-		const packages = discoverPackages(root);
-		if (packages.length === 0) this.#fail(`no @orkestrel packages under "${root}" — fleet scans the immediate children of the current directory; stand in the folder that contains your checkouts (cd ..), or use 'repair' to true up just this repo.`, json);
-		const host = values.from?.[0] ?? hostRoot();
-		const repos = [];
-		const failures = [];
-		for (const directory of packages) {
-			const name = basename(directory);
-			try {
-				const compiler = createCompiler();
-				let compiled;
-				let scoped;
-				let questions;
-				try {
-					const spec = deriveBlueprint(directory);
-					const scaffolding = compiler.compile(spec);
-					if (!scaffolding.plan) {
-						const message = scaffolding.questions.map((question) => question.text).join("; ");
-						throw new ScaffoldError("INVALID", message);
-					}
-					compiled = scaffolding.plan;
-					scoped = this.#scopeRepair(compiled, directory, generated);
-					questions = scaffolding.questions;
-				} finally {
-					compiler.destroy();
-				}
-				const plan = hydratePlan(scoped, host);
-				const paths = plan.artifacts.map((artifact) => artifact.path);
-				const rawAudit = {
-					...diffPlan(plan, readTarget(directory, paths)),
-					questions
-				};
-				const audit = this.#scan(rawAudit, directory, host, plan.blueprint.services);
-				const outside = this.#outside(compiled, plan, directory, host);
-				repos.push({
-					name,
-					directory,
-					plan,
-					rawAudit,
-					audit,
-					outside
-				});
-			} catch (error) {
-				failures.push({
-					name,
-					message: describeError(error)
-				});
-			}
-		}
-		if (!json) {
-			for (const repo of repos) {
-				this.#reporter.line(fleetRepoLine(repo.name, repo.audit.clean ? { state: "clean" } : {
-					state: "drifted",
-					drifted: repo.audit.drifted,
-					missing: repo.audit.missing,
-					foreign: repo.audit.foreign
-				}));
-				for (const question of repo.audit.questions) if (!question.blocking) this.#reporter.line(`${repo.name}: warning: ${question.text}`);
-				const note = scopeNote(repo.outside, generated);
-				if (note !== void 0) this.#reporter.line(`${repo.name}: ${note}`);
-			}
-			for (const failure of failures) this.#reporter.line(fleetRepoLine(failure.name, {
-				state: "failed",
-				message: failure.message
-			}));
-		}
-		const dirty = repos.filter((repo) => !repo.audit.clean);
-		const reportedDirty = repos.filter((repo) => hasFindings(repo.audit, repo.outside));
-		if (dirty.length === 0) {
-			if (json) this.#write([...repos.map((repo) => fleetEntryOf(repo.name, repo.audit, false, repo.outside)), ...failures.map((failure) => fleetEntryOf(failure.name, void 0, true))]);
-			else this.#reporter.line(fleetTotals(reportedDirty.length, failures.length));
-			process.exitCode = reportedDirty.length > 0 || failures.length > 0 ? 1 : 0;
-			return;
-		}
-		const fileCount = countWrites(dirty.map((repo) => repo.audit), replace);
-		if (!json && values.apply === true) this.#reporter.line(scopeLine("fleet", generated, dirty.length));
-		const terminal = createTerminal();
-		const proceed = await this.#apply(terminal, applyConfirmMessage(fileCount, dirty.length), values, json);
-		const pruneSets = proceed && values.prune ? new Map(dirty.map((repo) => {
-			const paths = this.#prunePaths(repo.directory, host, repo.plan.blueprint.services);
-			return [repo.name, readTarget(repo.directory, paths)];
-		})) : /* @__PURE__ */ new Map();
-		const prunePaths = dirty.flatMap((repo) => Object.keys(pruneSets.get(repo.name) ?? {}).map((path) => `${repo.name}/${path}`));
-		if (proceed && values.prune && !json) {
-			if (prunePaths.length === 0) this.#reporter.line(PRUNE_EMPTY);
-			else for (const line of prunePreview(prunePaths)) this.#reporter.line(line);
-		}
-		const doPrune = proceed && prunePaths.length > 0 && await this.#prune(terminal, pruneConfirmMessage(prunePaths.length), values, json);
-		if (!proceed) {
-			if (json) this.#write([...repos.map((repo) => fleetEntryOf(repo.name, repo.audit, false, repo.outside)), ...failures.map((failure) => fleetEntryOf(failure.name, void 0, true))]);
-			else this.#reporter.line(fleetTotals(reportedDirty.length, failures.length));
-			process.exitCode = 1;
-			return;
-		}
-		const materializer = createMaterializer({ host });
-		let drifted = repos.filter((repo) => repo.audit.clean && repo.outside > 0).length;
-		let failedCount = failures.length;
-		const entries = repos.filter((repo) => repo.audit.clean).map((repo) => fleetEntryOf(repo.name, repo.audit, false, repo.outside));
-		try {
-			for (const repo of dirty) try {
-				materializer.repair(repo.plan, repo.rawAudit, repo.directory, replace);
-				if (doPrune) materializer.prune(repo.directory, pruneSets.get(repo.name) ?? {});
-				const paths = repo.plan.artifacts.map((artifact) => artifact.path);
-				const rawFinal = diffPlan(repo.plan, readTarget(repo.directory, paths));
-				const finalAudit = this.#scan(rawFinal, repo.directory, host, repo.plan.blueprint.services);
-				if (hasFindings(finalAudit, repo.outside)) drifted += 1;
-				entries.push(fleetEntryOf(repo.name, finalAudit, false, repo.outside));
-				if (!json) this.#reporter.line(fleetRepoLine(repo.name, {
-					state: "repaired",
-					remaining: finalAudit.drifted + finalAudit.missing + finalAudit.foreign + repo.outside
-				}));
-			} catch (error) {
-				failedCount += 1;
-				entries.push(fleetEntryOf(repo.name, void 0, true));
-				if (!json) this.#reporter.line(fleetRepoLine(repo.name, {
-					state: "failed",
-					message: describeError(error)
-				}));
-			}
-		} finally {
-			materializer.destroy();
-		}
-		if (json) this.#write([...entries, ...failures.map((failure) => fleetEntryOf(failure.name, void 0, true))]);
-		else this.#reporter.line(fleetTotals(drifted, failedCount));
-		process.exitCode = drifted > 0 || failedCount > 0 ? 1 : 0;
-	}
-	/** `scaffold catalog` — regenerate the fleet package catalog table embedded in `.claude/agents/orkestrel.md`. */
-	async #catalog(values, json) {
-		const target = this.#contain(values.target ?? ".", json);
-		const explicitRoots = values.from;
-		let entries;
-		let published = 0;
-		let localOnly = 0;
-		const notes = /* @__PURE__ */ new Map();
-		if (values.offline) {
-			const roots = explicitRoots ?? [process.cwd()];
-			try {
-				entries = catalogPackages(roots);
-			} catch (error) {
-				this.#error(error, json);
-			}
-		} else {
-			const sync = createSync(this.#sync);
-			sync.emitter.on("package", (name, note) => {
-				if (note !== "") notes.set(name, note);
-			});
-			let registryEntries;
-			try {
-				registryEntries = await sync.catalog();
-			} catch (error) {
-				this.#error(error, json);
-			} finally {
-				sync.destroy();
-			}
-			published = registryEntries.length;
-			let localEntries = [];
-			if (explicitRoots !== void 0) try {
-				localEntries = catalogPackages(explicitRoots);
-			} catch (error) {
-				this.#error(error, json);
-			}
-			const merged = /* @__PURE__ */ new Map();
-			for (const entry of registryEntries) merged.set(entry.name, entry);
-			for (const local of localEntries) {
-				const existing = merged.get(local.name);
-				if (existing === void 0) {
-					merged.set(local.name, local);
-					localOnly += 1;
-				} else if (local.description.length > 0) merged.set(local.name, {
-					...existing,
-					description: local.description
-				});
-			}
-			entries = [...merged.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-		}
-		const block = catalogToBlock(entries);
-		const agentPath = this.#contain(join(target, CATALOG_AGENT_PATH), json);
-		let current;
-		let baseline;
-		try {
-			current = readFileText(target, CATALOG_AGENT_PATH, "TARGET", "target");
-			baseline = digestText(current);
-		} catch (error) {
-			this.#error(new ScaffoldError("TARGET", `Failed to read ${agentPath}`, {
-				path: agentPath,
-				error
-			}), json);
-		}
-		const startIndex = current.indexOf(CATALOG_START_MARKER);
-		const endIndex = current.indexOf(CATALOG_END_MARKER);
-		const startParts = current.split(CATALOG_START_MARKER);
-		const endParts = current.split(CATALOG_END_MARKER);
-		if (startIndex === -1 || endIndex === -1 || endIndex < startIndex || startParts.length !== 2 || endParts.length !== 2) this.#error(new ScaffoldError("TARGET", `Expected exactly one ordered "${CATALOG_START_MARKER}" / "${CATALOG_END_MARKER}" pair in ${agentPath}`, { path: agentPath }), json);
-		const updated = `${current.slice(0, startIndex + CATALOG_START_MARKER.length)}\n\n${block}\n${current.slice(endIndex)}`;
-		const oldBlock = current.slice(startIndex + CATALOG_START_MARKER.length, endIndex);
-		const oldRows = catalogNames(oldBlock).length;
-		const shrink = entries.length < oldRows ? oldRows - entries.length : void 0;
-		if (updated === current) {
-			if (json) this.#write(catalogResultOf(entries, false));
-			else this.#reporter.line(catalogVerdict(true));
-			process.exitCode = 0;
-			return;
-		}
-		if (!json) {
-			this.#reporter.table(catalogTable(entries));
-			const warning = catalogShrinkWarning(oldRows, entries.length);
-			if (warning !== void 0) this.#reporter.line(warning);
-			if (values.offline) {
-				const missingDescription = entries.filter((entry) => entry.description.length === 0).map((entry) => entry.name);
-				if (missingDescription.length > 0) this.#reporter.line(`${missingDescription.length} without guide description: ${missingDescription.join(", ")}`);
-			} else {
-				this.#reporter.line(catalogCounts(published, localOnly));
-				for (const [name, note] of notes) this.#reporter.line(`  ${name}: ${note}`);
-			}
-		}
-		const terminal = createTerminal();
-		if (!await this.#apply(terminal, applyConfirmMessage(1), values, json)) {
-			if (json) this.#write(catalogResultOf(entries, true, shrink));
-			else this.#reporter.line(catalogVerdict(false));
-			process.exitCode = 1;
-			return;
-		}
-		if (Buffer.byteLength(updated, "utf8") > MAX_ARTIFACT_BYTES) this.#error(new ScaffoldError("WRITE", `Catalog exceeds the artifact limit at ${agentPath}`, {
-			path: agentPath,
-			limit: MAX_ARTIFACT_BYTES
-		}), json);
-		const transaction = WriteTransaction.create(target, [CATALOG_AGENT_PATH], [{
-			path: CATALOG_AGENT_PATH,
-			shape: "file",
-			digest: baseline
-		}]);
-		const staged = attempt(() => {
-			validateWriteDirectories(transaction);
-			const destination = resolvePhysicalPath(transaction.stage, CATALOG_AGENT_PATH, "WRITE", "staging");
-			mkdirSync(dirname(destination), { recursive: true });
-			validateWriteDirectories(transaction);
-			const contained = resolvePhysicalPath(transaction.stage, CATALOG_AGENT_PATH, "WRITE", "staging");
-			writeFileSync(contained, updated, {
-				encoding: "utf8",
-				flag: "wx"
-			});
-			if (digestFile(contained) !== digestText(updated)) throw new ScaffoldError("WRITE", `Staged catalog changed at ${agentPath}`, { path: agentPath });
-			validateWriteDirectories(transaction);
-		});
-		if (!staged.success) {
-			const cleanup = attempt(() => discardWriteTransaction(transaction));
-			this.#error(new ScaffoldError("WRITE", `Failed to stage ${agentPath}`, {
-				path: agentPath,
-				error: staged.error,
-				cleanup: cleanup.success ? void 0 : cleanup.error
-			}), json);
-		}
-		const committed = attempt(() => commitWriteTransaction(transaction, [CATALOG_AGENT_PATH]));
-		if (!committed.success) this.#error(committed.error, json);
-		if (json) this.#write(catalogResultOf(entries, true, shrink));
-		else this.#reporter.status("success", catalogApplySuccess(agentPath));
-		process.exitCode = 0;
-	}
-	/**
-	* The whole command dispatch — a single top-level driver (no nested function
-	* declarations, AGENTS §4). Every verb sets `process.exitCode` (never
-	* `process.exit`) and returns, or `halt()`s through a `finally` that
-	* tears its entities down first; the caller at the bottom of this file
-	* catches exactly one sentinel (`CliExit`) and stops.
-	*/
-	async #dispatch(argv) {
-		let parsed;
-		try {
-			parsed = parseArguments(argv);
-		} catch (error) {
-			process.stderr.write(`${error instanceof Error ? error.message : INVALID_ARGUMENTS_MESSAGE}\n`);
-			process.exitCode = 2;
-			return;
-		}
-		const { values, positionals } = parsed;
-		const [command, argument] = positionals;
-		const json = values.json === true;
-		this.#json = json;
-		if (command === void 0) {
-			process.stdout.write(`${values.help ? fullHelp() : shortUsage()}\n`);
-			process.exitCode = 0;
-			return;
-		}
-		if (!isVerb(command)) this.#usage(didYouMean(command), json);
-		if (command !== "catalog" && values.from !== void 0 && values.from.length > 1) this.#usage(`--from may be provided only once for '${command}'`, json);
-		if (command === "mirror" && values.deps !== void 0) this.#usage("--deps is not supported for 'mirror'; use 'pull --deps'", json);
-		if (command === "fleet" && values.target !== void 0) this.#usage("--target is not supported for 'fleet'; change into the fleet root", json);
-		if (values.help) {
-			process.stdout.write(`${verbHelp(command)}\n`);
-			process.exitCode = 0;
-			return;
-		}
-		if (command === "new") return this.#new(values, argument, json);
-		if (command === "pull") return this.#pull(values, json);
-		if (command === "mirror") return this.#mirror(values, json);
-		if (command === "audit") return this.#audit(values, json);
-		if (command === "repair") return this.#repair(values, json);
-		if (command === "fleet") return this.#fleet(values, json);
-		return this.#catalog(values, json);
-	}
-};
-//#endregion
-//#region src/bin/scaffold.ts
-await new CLI().run(process.argv.slice(2));
-//#endregion
-
-//# sourceMappingURL=scaffold.js.map