@tryaura/aura-cli 0.2.0 → 0.2.1

package/dist/{run.boundary-BtMqQAEQ.js → run.boundary-CF5kZTH3.js}

@@ -1,4 +1,4 @@
-import { A as renderRemoveDiff, B as errorMessage$1, C as canonicalizeManagedSnippet, D as renderArchiveDiff, E as renderRedactedWriteDiff, F as assertAuraManifestWritable, H as resolveAuraManifestPath, I as createAuraManifestWriteOperation, K as pluralize, L as createEmptyAuraManifest, M as FILE_MODES, N as MAX_MUTABLE_FILE_BYTES, O as renderConflict, P as MAX_RETAINED_PLAN_BYTES, R as parseAuraManifest, S as readManagedBlock, T as hashManagedSnippet, U as AuraManifestError, V as isRecord$4, W as SHARED_INSTRUCTIONS_TEMPLATE, _ as planSharedSkillTreeUpdate, a as rememberMcpSecretPlanner, d as createAppMcpConvergence, g as managedContentRevisionStatus, j as renderSymlinkDiff, k as renderMoveDiff, m as sharedSkillsRoot, p as planSkillDeployment, q as displayPath, r as createAppMcpSecretPlanner, s as planDesiredMcpConvergence, t as planSharedInstructionLink, u as rememberMcpConvergence, v as reconcileParsedManagedBlock, w as hashCanonicalManagedSnippet, x as managedSnippetContentProblems, y as diffManagedSnippet, z as errorCode } from "./shared-link-plan-DVgOyqP9.js";
+import { A as renderRemoveDiff, B as errorMessage$1, C as canonicalizeManagedSnippet, D as renderArchiveDiff, E as renderRedactedWriteDiff, F as assertAuraManifestWritable, H as resolveAuraManifestPath, I as createAuraManifestWriteOperation, K as pluralize, L as createEmptyAuraManifest, M as FILE_MODES, N as MAX_MUTABLE_FILE_BYTES, O as renderConflict, P as MAX_RETAINED_PLAN_BYTES, R as parseAuraManifest, S as readManagedBlock, T as hashManagedSnippet, U as AuraManifestError, V as isRecord$4, W as SHARED_INSTRUCTIONS_TEMPLATE, _ as planSharedSkillTreeUpdate, a as rememberMcpSecretPlanner, d as createAppMcpConvergence, g as managedContentRevisionStatus, j as renderSymlinkDiff, k as renderMoveDiff, m as sharedSkillsRoot, p as planSkillDeployment, q as displayPath, r as createAppMcpSecretPlanner, s as planDesiredMcpConvergence, t as planSharedInstructionLink, u as rememberMcpConvergence, v as reconcileParsedManagedBlock, w as hashCanonicalManagedSnippet, x as managedSnippetContentProblems, y as diffManagedSnippet, z as errorCode } from "./shared-link-plan-D8fxdFYv.js";
 import { COMMAND_NOT_FOUND_EXIT_CODE, DEFAULT_EXEC_TIMEOUT_MS, DEFAULT_HTTP_TIMEOUT_MS, MAX_EXEC_OUTPUT_CHARACTERS, MAX_EXEC_TIMEOUT_MS, MAX_HTTP_RESPONSE_BYTES, MAX_HTTP_TIMEOUT_MS, NOT_EXECUTABLE_EXIT_CODE, OUTPUT_LIMIT_EXIT_CODE, SHARED_INSTRUCTIONS_TEMPLATE_TOKEN, TIMEOUT_EXIT_CODE, defineOwnProperty, detectExecutable, hasMcpRedaction, jsonPropertyPath, mcpEnvironmentVariableNames, mcpServerNameProblem, parseMcpServerDefinition, parseMcpServerManifest, parseSkillFrontmatter, parseSkillReferences, resolveMcpSecretNameCollisions, resolveSkillDirectory, splitSourceLines } from "@tryaura/aura-sdk";
 import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { Buffer as Buffer$1, isUtf8 } from "node:buffer";
@@ -64,8 +64,9 @@ function createExec(options) {
 	return (request) => execute(request, options);
 }
 function execute(request, options) {
+	if (request.signal?.aborted === true) return Promise.reject(abortReason(request.signal));
 	const timeoutMs = normalizeTimeout(request.timeoutMs);
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
 		const plan = planSpawn(request.command, request.args ?? [], options.platform);
 		const child = spawn(plan.command, [...plan.args], {
 			cwd: request.cwd ?? options.cwd,
@@ -78,7 +79,27 @@ function execute(request, options) {
 		let settled = false;
 		let stderr = "";
 		let stdout = "";
-		const timeout = setTimeout(() => {
+		let timeout;
+		let abortOnSignal;
+		const cleanUp = () => {
+			if (timeout !== void 0) clearTimeout(timeout);
+			if (abortOnSignal !== void 0) request.signal?.removeEventListener("abort", abortOnSignal);
+			child.stdout.destroy();
+			child.stderr.destroy();
+		};
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			cleanUp();
+			resolve(result);
+		};
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanUp();
+			reject(error);
+		};
+		timeout = setTimeout(() => {
 			terminate(child, options.platform);
 			finish({
 				exitCode: TIMEOUT_EXIT_CODE,
@@ -86,13 +107,9 @@ function execute(request, options) {
 				stdout
 			});
 		}, timeoutMs);
-		const finish = (result) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			child.stdout.destroy();
-			child.stderr.destroy();
-			resolve(result);
+		abortOnSignal = () => {
+			terminate(child, options.platform);
+			fail(abortReason(request.signal));
 		};
 		const abortOnOverflow = () => {
 			terminate(child, options.platform);
@@ -128,8 +145,14 @@ function execute(request, options) {
 			});
 		});
 		child.stdin.end(request.input);
+		request.signal?.addEventListener("abort", abortOnSignal, { once: true });
+		if (request.signal?.aborted === true) abortOnSignal();
 	});
 }
+/** The caller-selected reason, with the platform-standard fallback for a bare abort. */
+function abortReason(signal) {
+	return signal?.reason ?? new DOMException("The command was aborted.", "AbortError");
+}
 /**
 * Kills the command and every process it started.
 *
@@ -5022,6 +5045,7 @@ async function parseAdapter(adapter, detection, discovery, context) {
 			cwd: context.environment.cwd,
 			detection,
 			files: discovery.files,
+			gitMainWorktreeRoot: await context.gitMainWorktreeRoot,
 			homeDir: context.environment.homeDir,
 			projectRoot: await context.projectRoot
 		});
@@ -5502,6 +5526,26 @@ async function findProjectRoot(cwd, reader) {
 		directory = parent;
 	}
 }
+/**
+* Resolves the primary checkout Git uses as the trust boundary for a repository.
+*
+* A normal checkout keeps a `.git` directory and is its own primary checkout. A linked worktree
+* keeps a `gitdir:` file pointing at `<primary>/.git/worktrees/<id>` instead, so the primary
+* checkout is recovered from that standard Git layout without requiring the Git executable.
+*/
+async function findGitMainWorktreeRoot(projectRoot, reader) {
+	const marker = await reader.read(join(projectRoot, ".git"));
+	if (marker.problem !== void 0 || !marker.exists) return;
+	if (marker.isDirectory) return projectRoot;
+	if (marker.content === void 0) return;
+	const pointer = marker.content.trim().match(/^gitdir:\s*(.+)$/u)?.[1]?.trim();
+	if (pointer === void 0 || pointer.length === 0) return;
+	const gitDirectory = resolve(projectRoot, pointer);
+	const worktreesDirectory = dirname(gitDirectory);
+	if (basename(worktreesDirectory) !== "worktrees") return;
+	const mainWorktreeRoot = dirname(dirname(worktreesDirectory));
+	return await reader.realPath(mainWorktreeRoot) ?? mainWorktreeRoot;
+}
 //#endregion
 //#region ../core/src/workspace/repository.ts
 const GIT_TIMEOUT_MS = 5e3;
@@ -5668,6 +5712,24 @@ async function readTrackedPackageManifestPaths(command, projectRoot, environment
 	return [...new Set(result.stdout.split("\0").filter((path) => path.length > 0))].sort().slice(0, MAX_PACKAGE_MANIFESTS);
 }
 //#endregion
+//#region ../core/src/workspace/scan-cancellation.ts
+/** Injects one scan's cancellation into every command an adapter starts. */
+function withScanCancellation(environment, signal) {
+	if (signal === void 0) return environment;
+	return Object.freeze({
+		...environment,
+		exec: async (request) => {
+			signal.throwIfAborted();
+			const result = await environment.exec({
+				...request,
+				signal: request.signal === void 0 ? signal : AbortSignal.any([request.signal, signal])
+			});
+			signal.throwIfAborted();
+			return result;
+		}
+	});
+}
+//#endregion
 //#region ../core/src/skills/limits.ts
 /**
 * The largest directory index Aura will read, in bytes.
@@ -6004,11 +6066,15 @@ const skipMcpProbes = (servers) => Promise.resolve(servers);
 */
 async function buildWorkspaceModel(options) {
 	const reader = createCachingReader(options.reader ?? createFileReader());
-	const environment = await canonicalizeEnvironmentPaths(options.environment, reader);
+	options.signal?.throwIfAborted();
+	const environment = withScanCancellation(await canonicalizeEnvironmentPaths(options.environment, reader), options.signal);
+	options.signal?.throwIfAborted();
 	const projectRoot = findProjectRoot(environment.cwd, reader);
+	const gitMainWorktreeRoot = projectRoot.then((root) => root === void 0 ? void 0 : findGitMainWorktreeRoot(root, reader));
 	const context = {
 		documents: createDocumentResolver(reader),
 		environment,
+		gitMainWorktreeRoot,
 		projectBoundary: resolveProjectBoundary(projectRoot, environment.cwd, reader),
 		projectRoot,
 		probeMcpServers: options.mcpProbes === void 0 ? skipMcpProbes : createMcpProber({
@@ -6020,7 +6086,7 @@ async function buildWorkspaceModel(options) {
 	};
 	const sharedPath = sharedInstructionsPath(environment);
 	const manifestPath = resolveAuraManifestPath(environment.homeDir);
-	const scansPending = Promise.all(options.adapters.map((adapter) => scanAdapter(adapter, context)));
+	const scansPending = Promise.all(options.adapters.map((adapter) => reportingScan(adapter, context, options.onAdapterScan, options.signal)));
 	const repositoryPending = projectRoot.then((found) => found === void 0 ? void 0 : scanRepository(found, environment, reader));
 	const sharedContentsPending = reader.read(sharedPath);
 	const manifestContentsPending = reader.read(manifestPath);
@@ -6030,6 +6096,7 @@ async function buildWorkspaceModel(options) {
 	const sharedSkillsPending = scanSharedSkills(environment, reader);
 	const scans = await scansPending;
 	const root = await projectRoot;
+	const mainWorktreeRoot = await gitMainWorktreeRoot;
 	const repository = await repositoryPending;
 	const sharedContents = await sharedContentsPending;
 	const manifestContents = await manifestContentsPending;
@@ -6037,6 +6104,7 @@ async function buildWorkspaceModel(options) {
 	const resolvedCatalog = await resolvedCatalogPending;
 	const resolvedSkills = await resolvedSkillsPending;
 	const sharedSkills = await sharedSkillsPending;
+	options.signal?.throwIfAborted();
 	const apps = [];
 	const diagnostics = [];
 	const skipped = [];
@@ -6058,6 +6126,7 @@ async function buildWorkspaceModel(options) {
 			availableSnippets: resolvedSnippets.values,
 			apps,
 			cwd: environment.cwd,
+			...mainWorktreeRoot === void 0 ? {} : { gitMainWorktreeRoot: mainWorktreeRoot },
 			homeDir: environment.homeDir,
 			instructionFiles: apps.flatMap((app) => app.instructionFiles),
 			manifest,
@@ -6074,6 +6143,24 @@ async function buildWorkspaceModel(options) {
 		skipped
 	};
 }
+/** One adapter's scan bracketed by progress reports; `finally` keeps a throwing scan honest. */
+async function reportingScan(adapter, context, report, signal) {
+	reportScan(report, adapter.id, "active");
+	try {
+		signal?.throwIfAborted();
+		const scan = await scanAdapter(adapter, context);
+		signal?.throwIfAborted();
+		return scan;
+	} finally {
+		reportScan(report, adapter.id, "complete");
+	}
+}
+/** A progress sink is an observer, so its own failure cannot change the scan it watches. */
+function reportScan(report, adapterId, status) {
+	try {
+		report?.(adapterId, status);
+	} catch {}
+}
 function environmentVariableStates(manifest, environment) {
 	if (manifest.status !== "ready") return [];
 	return [...new Set(manifest.value.mcpServers.flatMap((server) => mcpEnvironmentVariableNames(server.transport)))].sort().map((name) => Object.freeze({
@@ -8070,24 +8157,45 @@ function hashRepoPreset(content) {
 }
 /** Reads and validates the repository preset below the invoking directory. */
 async function readRepoPreset(environment, reader = createFileReader()) {
-	const path = resolveTeamPresetPath(environment.cwd);
-	const state = await readTeamPreset(environment.cwd, reader);
+	const cwd = await reader.realPath(environment.cwd) ?? environment.cwd;
+	const path = resolveTeamPresetPath(cwd);
+	const state = await readTeamPreset(cwd, reader);
 	if (state.status !== "ready" || state.preset === void 0 || state.content === void 0) return {
 		diagnostics: state.diagnostics,
 		path,
 		status: state.status
 	};
+	const mainWorktreePath = await resolveMainWorktreePresetPath(cwd, path, reader);
 	return {
 		diagnostics: state.diagnostics,
 		hash: hashRepoPreset(state.content),
+		...mainWorktreePath === void 0 ? {} : { mainWorktreePath },
 		path,
 		preset: state.preset,
 		status: "ready"
 	};
 }
-/** Whether the manifest records an acceptance of exactly these repository preset contents. */
-function isRepoPresetTrusted(manifest, path, hash) {
-	return (manifest?.trustedRepoPresets ?? []).some((entry) => entry.path === path && entry.hash === hash);
+/** Whether the manifest records an acceptance of exactly these contents for this repository. */
+function isRepoPresetTrusted(manifest, identity, hash) {
+	return (manifest?.trustedRepoPresets ?? []).some((entry) => entry.hash === hash && (entry.path === identity.path || identity.mainWorktreePath !== void 0 && (entry.path === identity.mainWorktreePath || entry.mainWorktreePath === identity.mainWorktreePath)));
+}
+/**
+* Resolves the same preset path inside the repository's primary Git checkout.
+*
+* The preset keeps its position within the repository, so a run below the worktree root maps onto
+* the matching subdirectory of the primary checkout rather than onto its root. Returns undefined
+* outside a Git checkout, inside the primary checkout itself, and for any layout Git's own
+* `.git`-file convention does not describe.
+*/
+async function resolveMainWorktreePresetPath(cwd, path, reader) {
+	const projectRoot = await findProjectRoot(cwd, reader);
+	if (projectRoot === void 0) return;
+	const mainWorktreeRoot = await findGitMainWorktreeRoot(projectRoot, reader);
+	if (mainWorktreeRoot === void 0) return;
+	const within = relative(projectRoot, cwd);
+	if (within.startsWith("..") || isAbsolute(within)) return;
+	const candidate = resolveTeamPresetPath(join(mainWorktreeRoot, within));
+	return candidate === path ? void 0 : candidate;
 }
 //#endregion
 //#region ../core/src/preset/required-mcp.ts
@@ -8439,7 +8547,7 @@ async function resolveRuntimeConfig(input) {
 		message: `${repo.diagnostics[0]?.message ?? `Repository preset ${repo.path} cannot be read.`} Fix or remove the file to continue.`,
 		status: "invalid"
 	};
-	const repoTrusted = repo.status === "ready" && repo.hash !== void 0 && (repo.hash === input.acceptedRepoPresetHash || isRepoPresetTrusted(manifest, repo.path, repo.hash));
+	const repoTrusted = repo.status === "ready" && repo.hash !== void 0 && (repo.hash === input.acceptedRepoPresetHash || isRepoPresetTrusted(manifest, repo, repo.hash));
 	const resolved = resolveEffectiveConfig({
 		checks: input.registry.checks,
 		cli: input.cliLayer,
@@ -8477,6 +8585,7 @@ async function resolveRuntimeConfig(input) {
 		presetOrigin: loaded.status === "ready" ? loaded.origin : policyPreset?.name ?? ".aura/preset.json",
 		...repo.status === "ready" && repo.hash !== void 0 ? { repoPreset: {
 			hash: repo.hash,
+			...repo.mainWorktreePath === void 0 ? {} : { mainWorktreePath: repo.mainWorktreePath },
 			path: repo.path,
 			status: repoTrusted ? "applied" : "held"
 		} } : {},
@@ -8797,7 +8906,7 @@ function resolveStatus(findings, diagnostics, checks, forcedExitCode) {
 /** Describes the remediation mode and the command that can act on it. */
 const FIXABILITY_DESCRIPTIONS = Object.freeze({
 	auto: "auto — apply with check --fix",
-	guided: "guided — walk through choices with check --fix --interactive",
+	guided: "guided — choose from the options check --fix puts to you",
 	manual: "manual — follow the guidance below"
 });
 function renderExplanation(check, config, branding, output, configuration) {
@@ -8863,7 +8972,7 @@ function firstExplainConflict(options) {
 	return options.only ? "--only" : void 0;
 }
 function fixOptionRejection(options) {
-	return missingFixRejection(options) ?? contradictoryFixRejection(options) ?? interactiveTerminalRejection(options);
+	return missingFixRejection(options) ?? contradictoryFixRejection(options);
 }
 function missingFixRejection(options) {
 	const flag = firstFixDependentFlag(options.dryRun, options.interactive, options.yes);
@@ -8871,10 +8980,7 @@ function missingFixRejection(options) {
 }
 function contradictoryFixRejection(options) {
 	if (options.dryRun && options.yes) return "--dry-run and --yes contradict each other: one stops at the preview, the other applies without asking.";
-	if (options.interactive && options.yes) return "--interactive and --yes contradict each other: one asks for guided choices, the other forbids questions.";
-}
-function interactiveTerminalRejection(options) {
-	return options.interactive && (!options.stdinTerminal || !options.stdoutTerminal) ? "stdin and prompt output must both be terminals for --interactive." : void 0;
+	return options.interactive && options.yes ? "--interactive and --yes contradict each other: the deprecated alias asks for guided choices, while --yes forbids questions." : void 0;
 }
 function firstFixDependentFlag(dryRun, interactive, yes) {
 	if (dryRun) return "--dry-run";
@@ -8911,8 +9017,6 @@ function rejectInvalidFixOptions(options) {
 		dryRun: options.dryRun,
 		fix: options.fix,
 		interactive: options.interactive,
-		stdinTerminal: isTerminal(options.stdin),
-		stdoutTerminal: isTerminal(options.stdout),
 		yes: options.yes
 	});
 }
@@ -9258,16 +9362,36 @@ function editFreeText(keypress, state) {
 	return true;
 }
 /**
-* Toggles the multi-select option on `row`; a no-op on any other kind of row.
+* Marks the option on `row` without answering the question: a multiselect toggles it, a select
+* moves its single mark to it.
+*
+* Space stops at marking on purpose — the row shows what would stand, and ↵ is still the only key
+* that answers the question and moves on.
+*/
+function markRow(state, row, options = state.question.options) {
+	const marked = state.question.kind === "multiselect" ? toggle(state, row, options) : choose(state, row, options);
+	if (marked) state.answeredWithText = false;
+	return marked;
+}
+/**
+* Toggles the multi-select option on `row`.
 *
 * A disabled option can be cleared but never selected. Refusing both directions would strand any
 * selection that was seeded before the option became unavailable, with no way to give it up.
 */
-function toggleRow(state, row, options = state.question.options) {
+function toggle(state, row, options) {
+	const option = options[row];
+	if (option === void 0 || option.disabled === true && !state.selected.has(option.value)) return false;
+	if (state.selected.has(option.value)) state.selected.delete(option.value);
+	else state.selected.add(option.value);
+	return true;
+}
+/** Moves a select's single mark to `row`; a disabled option can never take it. */
+function choose(state, row, options) {
 	const option = options[row];
-	if (option === void 0 || state.question.kind !== "multiselect") return false;
-	if (option.disabled === true && !state.selected.has(option.value)) return false;
-	toggle(state.selected, option.value);
+	if (option === void 0 || option.disabled === true) return false;
+	state.selected.clear();
+	state.selected.add(option.value);
 	return true;
 }
 /** Answers the question with the row the cursor is on: free text, or a select's chosen option. */
@@ -9333,10 +9457,6 @@ function visibleOptions(state) {
 	const visibleValues = new Set(initial.map((option) => option.value));
 	return [...initial, ...state.question.options.filter((option) => state.selected.has(option.value) && !visibleValues.has(option.value))];
 }
-function toggle(selected, value) {
-	if (selected.has(value)) selected.delete(value);
-	else selected.add(value);
-}
 //#endregion
 //#region src/setup/wizard-form.ts
 function createFormSession(questions, flow) {
@@ -9446,11 +9566,11 @@ function createFormSession(questions, flow) {
 			preview = openPreview(option.preview, option.label);
 			return true;
 		}
-		if (keypress.name === "space") return toggleRow(state, cursorRow, options);
+		if (keypress.name === "space") return markRow(state, cursorRow, options);
 		const digit = digitRow(keypress, state.question, options.length);
 		if (digit === void 0) return false;
 		cursorRow = digit;
-		toggleRow(state, digit, options);
+		markRow(state, digit, options);
 		return true;
 	};
 	return {
@@ -9842,7 +9962,10 @@ function renderSubmitBody(questions, submitLocked, style) {
 function renderHint(question, submitLocked, searching) {
 	if (question === void 0) return submitLocked ? " ←/→ steps · esc cancel" : " ↵ submit · ←/→ steps · esc cancel";
 	if (searching) return " type to filter · ↑/↓ move · ↵ results · esc clear search";
-	return ` ↑/↓ move${question.kind === "multiselect" ? " · space toggle" : ""}${question.options.some((option) => option.preview !== void 0) ? " · p preview" : ""}${question.search === void 0 ? "" : " · / search"} · ←/→ steps · ↵ select · esc cancel`;
+	const multi = question.kind === "multiselect";
+	const mark = multi ? " · space toggle" : " · space select";
+	const commit = multi ? "↵ select" : "↵ confirm";
+	return ` ↑/↓ move${mark}${question.options.some((option) => option.preview !== void 0) ? " · p preview" : ""}${question.search === void 0 ? "" : " · / search"} · ←/→ steps · ${commit} · esc cancel`;
 }
 /**
 * Shows one screenful of the body, never more.
@@ -10195,17 +10318,37 @@ function keyText(key, field) {
 //#endregion
 //#region src/fix-confirmation.ts
 /**
+* Whether a check run would put guided questions on screen — the telemetry sense of interactive.
+*
+* `--json` promises one machine-readable document and a machine cannot answer, so that run declines
+* the questions it is otherwise able to ask.
+*/
+function runAsksGuided(options) {
+	return options.fix && !options.json && canPrompt(options, void 0);
+}
+/**
+* Whether this run can put a question on screen and read the answer.
+*
+* The guided step and the confirmation step ask the same thing of the same streams, so they read
+* the capability from here rather than each deciding for itself — a run that may not ask which
+* resolution to take may not ask whether to apply one either.
+*/
+function canPrompt(request, wizard) {
+	if (request.yes) return false;
+	return wizard !== void 0 || isTerminal(request.stdin) && isTerminal(request.stdout);
+}
+/**
 * One confirmation idiom for every fix path.
 *
-* A plain `check --fix` confirms through the same Apply/Cancel wizard form that setup, undo, and
-* `--fix --interactive` use, instead of presenting a second `[y/N]` dialect for the same decision.
-* A caller that already holds a wizard (the interactive branch, or a test's scripted seam) keeps
-* it; otherwise one is built here — only when both streams are terminals, so non-TTY runs still
-* report the prompt unavailable rather than hanging.
+* `check --fix` confirms through the same Apply/Cancel wizard form that setup, undo, and the guided
+* questions use, instead of presenting a second `[y/N]` dialect for the same decision. A caller
+* that already holds a wizard (the guided branch, or a test's scripted seam) keeps it; otherwise
+* one is built here — only when both streams are terminals, so non-TTY runs still report the prompt
+* unavailable rather than hanging.
 */
 async function confirmFixes(request, wizard) {
 	if (request.yes) return "accepted";
-	if (wizard === void 0 && (!isTerminal(request.stdin) || !isTerminal(request.stdout))) return "unavailable";
+	if (!canPrompt(request, wizard)) return "unavailable";
 	return await (wizard ?? createInteractiveWizardIo({
 		colorDepth: request.colorDepth,
 		stdin: request.stdin,
@@ -10261,10 +10404,23 @@ function reportFixes(prepared, status, withDetail, message) {
 * Candidates survive the preparation only when their plan does something, so candidates without a
 * single operation are plans made entirely of steps the user has to take. Reporting those as no
 * available fix contradicts the choice the user just made and hides the steps below it.
+*
+* `unasked` guided findings get no message at all here: {@link guidedNotice} is the whole sentence
+* for that run, and "no executable fixes are available" would deny the findings it is about to name.
 */
-function fixlessMessage(candidates, findings) {
+function fixlessMessage(candidates, findings, unasked) {
 	if (candidates > 0) return "Nothing to write: what these fixes need is listed below.\n\n";
-	return findings === 0 ? "Nothing to fix.\n\n" : "No executable fixes are available for the findings below.\n\n";
+	if (findings === 0) return "Nothing to fix.\n\n";
+	return unasked > 0 ? "" : "No executable fixes are available for the findings below.\n\n";
+}
+/**
+* Why a run that cannot ask questions left the guided fixes where they were.
+*
+* Every route to this sentence is one the user chose — `--yes`, `--json`, or a shell with no
+* terminal — so it names them rather than describing the run's state back at them.
+*/
+function guidedNotice(branding, unasked) {
+	return `Left ${String(unasked)} guided ${pluralize(unasked, "finding", "findings")} alone: this run cannot ask for the choices they need. Run ${branding.command} check --fix in a terminal, without --yes or --json.\n\n`;
 }
 function reportUnpreparedFixes(candidates) {
 	return candidates.flatMap((candidate) => {
@@ -10292,6 +10448,67 @@ function operationPaths(operation) {
 	return [operation.path];
 }
 //#endregion
+//#region src/preview-render.ts
+/**
+* Shows what applying the plan would do; only the shape of each change unless `withDetail`.
+*
+* Attribution goes through {@link operationsForCandidate} — the same way the report reads it — so
+* a coalesced operation prints under every check that asked for it. Grouping them under the check
+* that proposed each change is what lets the user judge the plan: the findings themselves have not
+* been printed yet at this point in the flow.
+*/
+function renderFixPreview(plan, withDetail, output) {
+	output.write(`Fix preview: ${safe(plan.prepared.preview.summary)}\n`);
+	for (const [candidateIndex, candidate] of plan.candidates.entries()) {
+		const operations = operationsForCandidate(plan, candidateIndex);
+		if (operations.every((operation) => operation.effect === "noop")) continue;
+		output.write(`  [${safe(candidate.checkId)}] ${safe(candidate.plan.summary)}\n`);
+		renderOperationPreviews(operations, withDetail, output, "    ");
+	}
+	if (!withDetail) output.write("\nRe-run with --detail to see the full diff of every change.\n");
+	renderManualSteps(plan.manualSteps, output);
+}
+/**
+* Prints the shape of each changed operation, one line per change.
+*
+* The diffs only under `withDetail`: a diff quotes the file it rewrites, and an instruction file is
+* exactly the kind of place a user pastes an API token, so the contents sit behind the same
+* `--detail` flag that gates a plugin's own error text.
+*/
+function renderOperationPreviews(operations, withDetail, output, indent = "  ") {
+	for (const operation of operations) {
+		if (operation.effect === "noop") continue;
+		output.write(`${indent}${operation.effect} ${operation.paths.map(safe).join(" -> ")}\n`);
+		if (operation.conflict !== void 0) output.write(`${indent}  blocked: ${safe(operation.conflict)}\n`);
+		if (withDetail) output.write(`\n${safeMultiline(operation.diff)}\n`);
+	}
+}
+/** Prints what the plan cannot do for the user, which is otherwise lost between preview and report. */
+function renderManualSteps(steps, output) {
+	if (steps.length === 0) return;
+	output.write("\nSteps to take yourself:\n");
+	for (const step of steps) output.write(`  - ${safe(step)}\n`);
+}
+//#endregion
+//#region src/fix-fixless.ts
+/**
+* Ends a run that wrote nothing, saying what it left rather than only what it could not do.
+*
+* A run that may not ask its guided questions has fixes it never attempted, and reporting those as
+* unavailable would contradict the report printed directly below it.
+*/
+function finishWithoutFixes(request, diagnostics, fixDiagnostics, outcome) {
+	request.stdout.write(outcome.message);
+	renderManualSteps(outcome.manualSteps, request.stdout);
+	if (outcome.unasked > 0) request.stdout.write(guidedNotice(request.branding, outcome.unasked));
+	return {
+		applied: false,
+		diagnostics,
+		fixDiagnostics,
+		fixes: []
+	};
+}
+//#endregion
 //#region src/setup/wizard-types.ts
 /** The answer a question proposes on its own, used by `--yes` and untouched forms. */
 function defaultAnswer(question) {
@@ -10333,9 +10550,13 @@ function foldDecisions(previous, answers, prefix, fallback) {
 }
 //#endregion
 //#region src/guided-fix.ts
+/** Keeps simultaneous path probes and retained preview buffers within a small fixed ceiling. */
+const MAX_CONCURRENT_GUIDED_PREVIEWS = 4;
 async function gatherGuidedFixes(request, wizard, diagnostics) {
 	const checks = new Map(request.checks.map((check) => [check.id, check]));
+	const limitPreview = createLimiter(MAX_CONCURRENT_GUIDED_PREVIEWS);
 	const selected = [];
+	const presented = /* @__PURE__ */ new Set();
 	for (const [index, finding] of request.findings.entries()) {
 		const check = checks.get(finding.checkId);
 		if (check?.fixability !== "guided" || finding.fixability === "manual") continue;
@@ -10351,8 +10572,9 @@ async function gatherGuidedFixes(request, wizard, diagnostics) {
 			});
 			continue;
 		}
-		if (choices.length === 0) continue;
-		const previewed = await Promise.all(choices.map(async (choice, choiceIndex) => {
+		if (choices.every((choice) => presented.has(choice.plan))) continue;
+		for (const choice of choices) presented.add(choice.plan);
+		const previewed = await Promise.all(choices.map((choice, choiceIndex) => limitPreview(async () => {
 			try {
 				return { option: await guidedOption(check, finding, choice, choiceIndex, request) };
 			} catch (error) {
@@ -10361,7 +10583,7 @@ async function gatherGuidedFixes(request, wizard, diagnostics) {
 					error
 				};
 			}
-		}));
+		})));
 		const options = [];
 		for (const outcome of previewed) {
 			if ("option" in outcome) {
@@ -10399,6 +10621,11 @@ async function gatherGuidedFixes(request, wizard, diagnostics) {
 	}
 	return Object.freeze(selected);
 }
+/** How many findings a run would have to ask about before it could fix them. */
+function guidedFindingCount(checks, findings) {
+	const guided = new Set(checks.filter((check) => check.fixability === "guided").map((check) => check.id));
+	return findings.filter((finding) => guided.has(finding.checkId) && finding.fixability !== "manual").length;
+}
 function orderCandidates(candidates, findings) {
 	const order = new Map(findings.map((finding, index) => [`${finding.checkId}\0${finding.id}`, index]));
 	return [...candidates].sort((left, right) => (order.get(`${left.checkId}\0${left.findingId}`) ?? Number.MAX_SAFE_INTEGER) - (order.get(`${right.checkId}\0${right.findingId}`) ?? Number.MAX_SAFE_INTEGER));
@@ -10439,60 +10666,6 @@ async function guidedOption(check, finding, choice, choiceIndex, request) {
 	};
 }
 //#endregion
-//#region src/preview-render.ts
-/**
-* Shows what applying the plan would do; only the shape of each change unless `withDetail`.
-*
-* Attribution goes through {@link operationsForCandidate} — the same way the report reads it — so
-* a coalesced operation prints under every check that asked for it. Grouping them under the check
-* that proposed each change is what lets the user judge the plan: the findings themselves have not
-* been printed yet at this point in the flow.
-*/
-function renderFixPreview(plan, withDetail, output) {
-	output.write(`Fix preview: ${safe(plan.prepared.preview.summary)}\n`);
-	for (const [candidateIndex, candidate] of plan.candidates.entries()) {
-		const operations = operationsForCandidate(plan, candidateIndex);
-		if (operations.every((operation) => operation.effect === "noop")) continue;
-		output.write(`  [${safe(candidate.checkId)}] ${safe(candidate.plan.summary)}\n`);
-		renderOperationPreviews(operations, withDetail, output, "    ");
-	}
-	if (!withDetail) output.write("\nRe-run with --detail to see the full diff of every change.\n");
-	renderManualSteps(plan.manualSteps, output);
-}
-/**
-* Names `--interactive` when it is the thing that would have helped.
-*
-* `--fix` only builds plans for `auto` checks, so a workspace whose findings are all `guided`
-* otherwise reads as "nothing can be done" when in fact the next flag along does exactly what the
-* user asked for.
-*/
-function renderGuidedHint(checks, findings, branding, output) {
-	const guided = new Set(checks.filter((check) => check.fixability === "guided").map((check) => check.id));
-	if (!findings.some((finding) => guided.has(finding.checkId))) return;
-	output.write(`Some of these findings offer guided resolutions. Run ${branding.command} check --fix --interactive to choose one.\n\n`);
-}
-/**
-* Prints the shape of each changed operation, one line per change.
-*
-* The diffs only under `withDetail`: a diff quotes the file it rewrites, and an instruction file is
-* exactly the kind of place a user pastes an API token, so the contents sit behind the same
-* `--detail` flag that gates a plugin's own error text.
-*/
-function renderOperationPreviews(operations, withDetail, output, indent = "  ") {
-	for (const operation of operations) {
-		if (operation.effect === "noop") continue;
-		output.write(`${indent}${operation.effect} ${operation.paths.map(safe).join(" -> ")}\n`);
-		if (operation.conflict !== void 0) output.write(`${indent}  blocked: ${safe(operation.conflict)}\n`);
-		if (withDetail) output.write(`\n${safeMultiline(operation.diff)}\n`);
-	}
-}
-/** Prints what the plan cannot do for the user, which is otherwise lost between preview and report. */
-function renderManualSteps(steps, output) {
-	if (steps.length === 0) return;
-	output.write("\nSteps to take yourself:\n");
-	for (const step of steps) output.write(`  - ${safe(step)}\n`);
-}
-//#endregion
 //#region src/fix.ts
 async function runFixes(request) {
 	const automatic = collectAutomaticFixCandidates({
@@ -10504,7 +10677,8 @@ async function runFixes(request) {
 	let candidates = [...automatic.candidates];
 	let wizard = request.wizard;
 	let guidedAborted = false;
-	if (request.interactive) {
+	const asksGuided = request.guidedChoices && canPrompt(request, wizard);
+	if (asksGuided) {
 		wizard ??= createInteractiveWizardIo({
 			colorDepth: request.colorDepth,
 			stdin: request.stdin,
@@ -10543,8 +10717,20 @@ async function runFixes(request) {
 		fixDiagnostics,
 		fixes: reportFixes(prepared, "planned", request.withDetail, "Aborted before confirmation. Nothing was changed.")
 	};
-	if (prepared.prepared === void 0) return finishWithoutFixes(request, automatic.diagnostics, fixDiagnostics, prepared.manualSteps, fixlessMessage(prepared.candidates.length, request.findings.length));
-	if (prepared.prepared.preview.changedOperationCount === 0 && prepared.prepared.preview.conflictedOperationCount === 0) return finishWithoutFixes(request, automatic.diagnostics, fixDiagnostics, prepared.manualSteps, "The planned fixes already match the current file contents.\n\n");
+	const unasked = asksGuided ? 0 : guidedFindingCount(request.checks, request.findings);
+	if (prepared.prepared === void 0) {
+		const message = fixlessMessage(prepared.candidates.length, request.findings.length, unasked);
+		return finishWithoutFixes(request, automatic.diagnostics, fixDiagnostics, {
+			manualSteps: prepared.manualSteps,
+			message,
+			unasked
+		});
+	}
+	if (prepared.prepared.preview.changedOperationCount === 0 && prepared.prepared.preview.conflictedOperationCount === 0) return finishWithoutFixes(request, automatic.diagnostics, fixDiagnostics, {
+		manualSteps: prepared.manualSteps,
+		message: "The planned fixes already match the current file contents.\n\n",
+		unasked
+	});
 	renderFixPreview(prepared, request.withDetail, request.stdout);
 	if (prepared.prepared.preview.conflictedOperationCount > 0) {
 		request.stderr.write(`${request.branding.displayName}: fixes are blocked by the current state of these files; nothing was changed.\n`);
@@ -10642,17 +10828,6 @@ async function runFixes(request) {
 		};
 	}
 }
-function finishWithoutFixes(request, diagnostics, fixDiagnostics, manualSteps, message) {
-	request.stdout.write(message);
-	renderManualSteps(manualSteps, request.stdout);
-	if (!request.interactive) renderGuidedHint(request.checks, request.findings, request.branding, request.stdout);
-	return {
-		applied: false,
-		diagnostics,
-		fixDiagnostics,
-		fixes: []
-	};
-}
 //#endregion
 //#region src/render.ts
 function renderJson(report, output) {
@@ -10982,7 +11157,7 @@ function renderRecommendation(report, branding, output, context) {
 	if (fixable.length === 0) return;
 	const automatic = fixable.filter((finding) => finding.fixability === "auto").length;
 	const guided = fixable.length - automatic;
-	const command = `${branding.command} check --fix${guided > 0 ? " --interactive" : ""}`;
+	const command = `${branding.command} check --fix`;
 	const modes = [...automatic > 0 ? [`${String(automatic)} automatic`] : [], ...guided > 0 ? [`${String(guided)} guided`] : []];
 	renderSection("▶", "Recommended next step", [
 		command,
@@ -11063,9 +11238,8 @@ var CheckCommand = class extends Command {
 			["Explain one check without scanning", "$0 check --explain ENV-001"],
 			["Explain one check as JSON", "$0 check --explain ENV-001 --json"],
 			["See what fixing would change, without writing", "$0 check --fix --dry-run"],
-			["Apply fixes after confirming them", "$0 check --fix"],
-			["Apply fixes without being asked", "$0 check --fix --yes"],
-			["Choose guided resolutions", "$0 check --fix --interactive"]
+			["Choose resolutions, then apply them", "$0 check --fix"],
+			["Apply automatic fixes without being asked", "$0 check --fix --yes"]
 		]
 	});
 	detail = Option.Boolean("--detail", false, { description: "Include the failing plugin's own error text. May contain file contents." });
@@ -11073,20 +11247,29 @@ var CheckCommand = class extends Command {
 	dryRun = Option.Boolean("--dry-run", false, { description: "With --fix, show what would change and write nothing." });
 	explain = Option.String("--explain", { description: "Explain a check without scanning." });
 	enable = enableOption();
-	fix = Option.Boolean("--fix", false, { description: "Preview fixes and apply them after confirmation." });
+	fix = Option.Boolean("--fix", false, { description: "Choose any guided resolutions, preview, and apply after confirmation." });
 	home = homeOption();
 	json = Option.Boolean("--json", false, { description: "Emit JSON instead of human output." });
 	jsonVersion = Option.String("--json-version", { description: "Select the machine-readable contract version. Supported: 1." });
+	legacyInteractive = Option.Boolean("--interactive", false, { hidden: true });
 	only = Option.Array("--only", [], { description: "Run only a check ID, category, or application. Repeatable." });
 	online = Option.Boolean("--online", false, { description: "Probe remote MCP URLs with bounded network requests." });
 	noCache = noCacheOption();
-	interactive = Option.Boolean("--interactive", false, { description: "With --fix, walk through guided remediation choices." });
 	pathValue = pathOption();
 	preset = presetOption();
 	severity = severityOption();
 	threshold = thresholdOption();
 	verbose = Option.Boolean("--verbose", false, { description: "Expand occurrences and locations; add passed checks and applications." });
-	yes = Option.Boolean("--yes", false, { description: "Apply fixes without asking. Required when stdin is not a terminal." });
+	yes = Option.Boolean("--yes", false, { description: "Apply automatic fixes without asking. Required when stdin is not a terminal." });
+	get interactive() {
+		return runAsksGuided({
+			fix: this.fix,
+			json: this.json,
+			stdin: this.context.stdin,
+			stdout: this.context.stdout,
+			yes: this.yes
+		});
+	}
 	async execute() {
 		const rejection = rejectInvalidCheckOptions({
 			detail: this.detail,
@@ -11094,14 +11277,12 @@ var CheckCommand = class extends Command {
 			explaining: this.explain !== void 0,
 			fix: this.fix,
 			home: this.home,
-			interactive: this.interactive,
+			interactive: this.legacyInteractive,
 			json: this.json,
 			jsonVersion: this.jsonVersion,
 			online: this.online,
 			only: this.only,
 			pathValue: this.pathValue,
-			stdin: this.context.stdin,
-			stdout: this.context.stdout,
 			verbose: this.verbose,
 			yes: this.yes
 		});
@@ -11166,7 +11347,7 @@ var CheckCommand = class extends Command {
 					dryRun: this.dryRun,
 					environment,
 					findings: run.findings,
-					interactive: this.interactive,
+					guidedChoices: !this.json,
 					model,
 					stderr: this.context.stderr,
 					stdin: this.context.stdin,
@@ -11319,11 +11500,8 @@ function renderCheckHelp(branding) {
 		},
 		{
 			rows: [{
-				term: "--interactive",
-				text: "With --fix, walk through guided remediation choices"
-			}, {
 				term: "--yes",
-				text: "Apply without asking; required when stdin is not a terminal"
+				text: "Apply automatic fixes without asking; required when stdin is not a terminal"
 			}],
 			title: "Fixing behavior"
 		},
@@ -11382,7 +11560,11 @@ function renderSetupHelp(branding, addKinds) {
 			rows: advancedRows(),
 			title: "Advanced"
 		}
-	], [`After setup, run '${bin} check' to verify the machine converged`, "Exit codes: 0 applied/converged/dry-run/declined · 1 aborted or warnings · 2 conflicts/errors/invalid usage · 3 operational failures"]);
+	], [
+		`Consolidating moves the instruction files you select; '${bin} undo' restores them`,
+		`After setup, run '${bin} check' to verify the machine converged`,
+		"Exit codes: 0 applied/converged/dry-run/declined · 1 aborted or warnings · 2 conflicts/errors/invalid usage · 3 operational failures"
+	]);
 }
 function renderUndoHelp(branding) {
 	const bin = branding.command;
@@ -11656,11 +11838,15 @@ function repoPresetNotices(context) {
 		kind: "repo",
 		message: `${AURA_TEAM_PRESET_PATH} was not applied. Run setup interactively to review and trust it.`
 	}];
-	return repo.checkSummary.map((message, index) => ({
+	return [...repo.recorded ? [{
+		heading: "Repository preset trust recorded before this plan:",
+		kind: "repo",
+		message: `Trust of ${AURA_TEAM_PRESET_PATH} is already saved; declining or aborting this plan keeps it.`
+	}] : [], ...repo.checkSummary.map((message, index) => ({
 		...index === 0 ? { heading: `Effective check policy from the repository preset ${AURA_TEAM_PRESET_PATH} (not copied into your manifest):` } : {},
 		kind: "repo",
 		message
-	}));
+	}))];
 }
 /** The check values one layer supplied, in the wording the policy summaries share. */
 function presetCheckSummary(config, layer) {
@@ -11690,10 +11876,11 @@ async function establishRepoPresetTrust(options) {
 	const repo = await readRepoPreset(options.environment);
 	if (repo.status !== "ready" || repo.hash === void 0) return { kind: "resolved" };
 	const manifest = options.manifest.status === "ready" ? options.manifest.value : void 0;
-	if (isRepoPresetTrusted(manifest, repo.path, repo.hash) || !options.interactive) return { kind: "resolved" };
+	if (isRepoPresetTrusted(manifest, repo, repo.hash) || !options.interactive) return { kind: "resolved" };
 	const name = repo.preset?.name;
 	options.io.note(name === void 0 ? `This repository provides a preset at ${AURA_TEAM_PRESET_PATH}.` : `This repository provides the preset "${safe(name)}" at ${AURA_TEAM_PRESET_PATH}.`);
 	if (repo.preset !== void 0) options.io.note(repoPresetTrustPreview(repo.preset));
+	if (repo.mainWorktreePath !== void 0) options.io.note("This directory is a linked worktree, so trusting these contents also applies them in every other worktree of the same checkout.");
 	const changed = (manifest?.trustedRepoPresets ?? []).some((entry) => entry.path === repo.path);
 	const confirmation = await options.io.confirm(changed ? `The repository preset at ${AURA_TEAM_PRESET_PATH} changed since you trusted it. Trust the new contents?` : `Trust the repository preset at ${AURA_TEAM_PRESET_PATH}? Its settings apply to every Aura run in this repository until the file changes.`);
 	if (confirmation === "aborted") return { kind: "aborted" };
@@ -11714,9 +11901,16 @@ function repoPresetTrustPreview(preset) {
 	].filter((line) => line !== void 0);
 	return ["Review these repository-controlled settings before trusting:", ...settings.length === 0 ? ["No check, MCP, skill, or snippet settings."] : settings].join("\n");
 }
+/** The exact check settings the repository preset asks the user to trust. */
 function checksPreview(checks) {
 	if (checks === void 0) return;
-	return `Checks: ${safe(JSON.stringify(checks) ?? "{}")}`;
+	const settings = [
+		...(checks.disabled ?? []).map((id) => `${safe(id)}: disabled`),
+		...(checks.enabled ?? []).map((id) => `${safe(id)}: enabled`),
+		...Object.entries(checks.severity ?? {}).map(([id, severity]) => `${safe(id)}: severity ${safe(severity)}`),
+		...Object.entries(checks.thresholds ?? {}).map(([id, thresholds]) => `${safe(id)}: thresholds ${safe(JSON.stringify(thresholds))}`)
+	].sort();
+	return `Checks: ${settings.length === 0 ? "(none)" : settings.join("; ")}`;
 }
 function directoryPreview(source) {
 	const token = source.kind === "private-directory" ? `; token ${safe(source.tokenEnv)}` : "";
@@ -11728,41 +11922,186 @@ function listPreview(label, values) {
 function listValues(values) {
 	return values.length === 0 ? "(none)" : values.map(safe).join(", ");
 }
+/**
+* Whether this run's prompt accepted exactly the contents the resolved layer applied.
+*
+* The two reads of the file — the prompt's and configuration resolution's — are independent, so a
+* write that lands between them leaves the layer held. Recording trust for a layer that did not
+* apply would claim consent for settings this run never used.
+*/
+function acceptedRepoPreset(configured, acceptedHash) {
+	const repo = configured.repoPreset;
+	return repo !== void 0 && repo.status === "applied" && repo.hash === acceptedHash;
+}
 /** The repository-preset slice steps and the planner read, absent when no file exists. */
-function setupRepoPresetContext(configured, acceptedHash) {
+function setupRepoPresetContext(configured, acceptedHash, recorded) {
 	const repo = configured.repoPreset;
 	if (repo === void 0) return;
 	return Object.freeze({
-		accepted: repo.status === "applied" && repo.hash === acceptedHash,
+		accepted: acceptedRepoPreset(configured, acceptedHash),
 		checkSummary: repo.status === "applied" ? presetCheckSummary(configured.config, "repo") : Object.freeze([]),
 		hash: repo.hash,
+		...repo.mainWorktreePath === void 0 ? {} : { mainWorktreePath: repo.mainWorktreePath },
 		path: repo.path,
+		recorded,
 		status: repo.status
 	});
 }
-/** Records one accepted repository preset, replacing any earlier acceptance for the same path. */
+/** Records one accepted repository preset while retaining earlier accepted contents. */
 function withTrustedRepoPreset(manifest, record) {
-	const entries = [...(manifest.trustedRepoPresets ?? []).filter((entry) => entry.path !== record.path), record].slice(-64);
+	const entries = [...(manifest.trustedRepoPresets ?? []).filter((entry) => entry.path !== record.path || entry.hash !== record.hash), record].slice(-64);
 	return {
 		...manifest,
 		trustedRepoPresets: entries
 	};
 }
 //#endregion
+//#region src/setup/scan-loading.ts
+/** What the loading frame says while the machine scan finishes. */
+const SCAN_PROMPT = "Scanning this machine…";
+/**
+* Starts the boot scan immediately and defers the waiting to a wizard loading frame.
+*
+* The scan begins before any prompt so its slowest probes overlap the user's reading time, but a
+* loading frame can only exist once the wizard is ready to paint one. This tracker holds the gap
+* between the two: adapter progress reported before the frame opens is buffered and replayed into
+* it, progress after flows through live, and a scan that settles before the wizard needs it skips
+* the frame entirely — the same contract as a memoized skill listing.
+*
+* The returned settle function is the only consumer of the scan's outcome. A rejection while a
+* prompt is still open is held for it rather than crashing the process as unhandled; settle
+* rethrows it where boot's caller already handles scan failures.
+*/
+function trackBootScan(adapters, start) {
+	const statuses = /* @__PURE__ */ new Map();
+	let frame;
+	let settled = false;
+	const pending = start((adapterId, status) => {
+		statuses.set(adapterId, status);
+		frame?.(adapterId, status);
+	});
+	pending.then(() => {
+		settled = true;
+	}, () => {
+		settled = true;
+	});
+	return (io) => {
+		if (settled || adapters.length === 0) return pending;
+		return io.load({
+			items: adapters.map((adapter) => ({
+				id: adapter.id,
+				label: adapter.displayName
+			})),
+			prompt: SCAN_PROMPT
+		}, (update) => {
+			for (const [adapterId, status] of statuses) update(adapterId, status);
+			frame = update;
+			return pending;
+		});
+	};
+}
+//#endregion
+//#region src/setup/trust-record.ts
+/**
+* Persists an accepted repository preset before the wizard opens.
+*
+* Consent is not a configuration choice. A user who reviews the file, trusts it, and then backs
+* out of a wizard step has still answered the security question, and asking it again on the next
+* run is how a person learns to accept without reading. So the acceptance is written the moment it
+* is established, as its own one-operation plan, rather than riding along with the plan the wizard
+* confirms — which a run that never reaches the confirmation would discard.
+*/
+async function bootRepoPresetTrust(request, configured, acceptedHash, scan) {
+	const repo = configured.repoPreset;
+	if (repo === void 0 || !acceptedRepoPreset(configured, acceptedHash)) return {
+		repoPreset: setupRepoPresetContext(configured, acceptedHash, false),
+		scan
+	};
+	if (request.dryRun) {
+		request.io.note(`Dry run: the acceptance of ${AURA_TEAM_PRESET_PATH} was not recorded, so the next run asks again.`);
+		return {
+			repoPreset: setupRepoPresetContext(configured, acceptedHash, false),
+			scan
+		};
+	}
+	const recorded = await recordRepoPresetTrust({
+		environment: request.environment,
+		hash: repo.hash,
+		mainWorktreePath: repo.mainWorktreePath,
+		model: scan.model,
+		path: repo.path,
+		stateHomeDir: request.stateHomeDir
+	});
+	if (recorded.manifest === void 0) {
+		request.stderr.write(`${request.branding.displayName}: could not record your trust of ${AURA_TEAM_PRESET_PATH} yet (${safe(recorded.problem)}). It applies to this run and is recorded when you apply the plan.\n`);
+		return {
+			repoPreset: setupRepoPresetContext(configured, acceptedHash, false),
+			scan
+		};
+	}
+	return {
+		repoPreset: setupRepoPresetContext(configured, acceptedHash, true),
+		scan: {
+			...scan,
+			model: {
+				...scan.model,
+				manifest: recorded.manifest
+			}
+		}
+	};
+}
+/** Writes one accepted repository preset to the manifest through the fix-plan kernel. */
+async function recordRepoPresetTrust(options) {
+	const state = options.model.manifest;
+	try {
+		const desired = withTrustedRepoPreset(state.status === "ready" ? state.value : createEmptyAuraManifest(), {
+			hash: options.hash,
+			...options.mainWorktreePath === void 0 ? {} : { mainWorktreePath: options.mainWorktreePath },
+			path: options.path
+		});
+		await applyFixPlan(await prepareFixPlan({
+			model: options.model,
+			plan: {
+				operations: [createAuraManifestWriteOperation(state, desired)],
+				summary: "Record the repository preset you trusted."
+			}
+		}), {
+			now: options.environment.now,
+			stateHomeDir: options.stateHomeDir
+		});
+		return { manifest: readAuraManifest(state.path, await createFileReader().read(state.path)) };
+	} catch (error) {
+		if (error instanceof FixPlanError || error instanceof AuraManifestError) return { problem: error.message };
+		throw error;
+	}
+}
+//#endregion
 //#region src/setup/boot.ts
 /**
 * Resolves configuration, scans the machine, and projects preset requirements onto the model.
 *
 * All of it happens before the first wizard prompt so the wizard never asks a question it will
 * then have to take back — an unusable manifest or an unresolvable preset stops the run while
-* nothing has been shown and nothing has been written. The one exception is the repository preset
-* trust confirmation: its answer decides whether the repo layer joins the configuration at all, so
-* it must precede resolution, and the read-only manifest check runs before it so it is never asked
-* for a run that is already dead.
+* nothing has been shown and nothing has been written. Repository preset trust is the exception on
+* both counts: its answer decides whether the repo layer joins the configuration at all, so the
+* confirmation must precede resolution, and an accepted answer is written here, before the wizard
+* opens, so that backing out of a wizard step does not discard a security decision the user has
+* already made and get them asked again. The read-only manifest check runs before the prompt so it
+* is never asked for a run that is already dead.
+*
+* The full scan starts the moment the trust prompt resolves and is awaited last, behind a wizard
+* loading frame, so nothing user-visible ever waits on it silently. The prompt needs only the
+* manifest read and therefore appears instantly; the scan's slowest probes (an adapter execing a
+* companion CLI can take many seconds) then overlap configuration resolution, and whatever
+* remains is spent on an animated per-adapter frame rather than a dead terminal. Starting after
+* the prompt keeps an aborted run's guarantee intact — backing out of the trust question still
+* means no adapter ever ran — while an invalid configuration cancels the speculative scan.
 */
 async function bootSetup(request, environment) {
-	const manifestPath = resolveAuraManifestPath(environment.homeDir);
-	const manifest = readAuraManifest(manifestPath, await createFileReader().read(manifestPath));
+	const reader = createFileReader();
+	const homeDir = await reader.realPath(environment.homeDir) ?? environment.homeDir;
+	const manifestPath = resolveAuraManifestPath(homeDir);
+	const manifest = readAuraManifest(manifestPath, await reader.read(manifestPath));
 	if (manifest.status === "read-only") return {
 		message: manifest.problem.message,
 		status: "invalid"
@@ -11774,6 +12113,16 @@ async function bootSetup(request, environment) {
 		manifest
 	});
 	if (trust.kind === "aborted") return { status: "aborted" };
+	const scanCancellation = new AbortController();
+	const settleScan = trackBootScan(request.registry.adapters, (report) => buildWorkspaceModel({
+		adapters: request.registry.adapters,
+		environment,
+		mcpCatalog: request.registry.mcpServers,
+		onAdapterScan: report,
+		signal: scanCancellation.signal,
+		snippets: request.registry.snippets,
+		skills: request.registry.skills
+	}));
 	const configured = await resolveRuntimeConfig({
 		acceptedRepoPresetHash: trust.acceptedHash,
 		cliLayer: request.cliLayer,
@@ -11786,27 +12135,25 @@ async function bootSetup(request, environment) {
 		online: true,
 		registry: request.registry
 	});
-	if (configured.status === "invalid") return configured;
-	const scan = await buildWorkspaceModel({
-		adapters: request.registry.adapters,
-		environment,
-		mcpCatalog: request.registry.mcpServers,
-		snippets: request.registry.snippets,
-		skills: request.registry.skills
-	});
-	const projected = applyRequiredMcpServers(scan.model, configured.config);
+	if (configured.status === "invalid") {
+		scanCancellation.abort();
+		return configured;
+	}
+	const scan = await settleScan(request.io);
+	const trusted = await bootRepoPresetTrust(request, configured, trust.acceptedHash, scan);
+	const projected = applyRequiredMcpServers(trusted.scan.model, configured.config);
 	return {
-		...trust.acceptedHash === void 0 ? {} : { acceptedRepoPresetHash: trust.acceptedHash },
 		activeChecks: enabledChecks(request.registry.checks, configured.config),
 		configured,
 		effectiveModel: projected.model,
 		effectiveScan: {
-			...scan,
-			diagnostics: [...scan.diagnostics, ...projected.diagnostics],
+			...trusted.scan,
+			diagnostics: [...trusted.scan.diagnostics, ...projected.diagnostics],
 			model: projected.model
 		},
 		projected,
-		scan,
+		...trusted.repoPreset === void 0 ? {} : { repoPreset: trusted.repoPreset },
+		scan: trusted.scan,
 		status: "ready"
 	};
 }
@@ -12013,6 +12360,123 @@ function withIgnoredAppSelections(manifest, previous, apps, appCatalog) {
 	};
 }
 //#endregion
+//#region src/setup/managed-apps.ts
+/** Managed ids from this wizard pass, falling back to the persisted selection for targeted runs. */
+function managedAppIdList(context) {
+	if (context.selections.apps !== void 0) return context.selections.apps.managed;
+	return context.manifest.status === "ready" ? Object.entries(context.manifest.value.apps).filter(([, app]) => app.managed).map(([id]) => id) : [];
+}
+//#endregion
+//#region src/setup/instruction-links.ts
+/** Wires every managed application to the scope targets that survived planning. */
+function planLinks$1(context, scopeSelections, archived, ownership, manualSteps) {
+	const managedIds = new Set(managedAppIdList(context));
+	const operations = [];
+	for (const app of context.model.apps) {
+		if (app.synthetic === true || !managedIds.has(app.adapterId)) continue;
+		operations.push(...planAppLinks(context, app, scopeSelections, archived, ownership, manualSteps));
+	}
+	return operations;
+}
+function planAppLinks(context, app, scopeSelections, archived, ownership, manualSteps) {
+	return scopeSelections.flatMap((selection) => {
+		const link = selection.scope === "global" ? app.sharedLink : app.projectSharedLink;
+		if (link === void 0) return [];
+		const outcome = planSharedInstructionLink(app, context.model, {
+			link,
+			...archived.has(resolve(link.entryPath)) ? { sourceContent: "" } : {},
+			symlinkTarget: selection.targetPath
+		});
+		if ("blocked" in outcome) {
+			manualSteps.push(`Aura could not wire ${link.entryPath}: ${outcome.blocked}`);
+			return [];
+		}
+		manualSteps.push(...outcome.plan.manualSteps ?? []);
+		const files = ownership.get(app.adapterId) ?? [];
+		files.push(link.entryPath);
+		ownership.set(app.adapterId, files);
+		return [...outcome.plan.operations];
+	});
+}
+//#endregion
+//#region src/setup/instruction-merge.ts
+/**
+* Merges the selected sources into what the target should contain.
+*
+* Convergent by construction, because setup's contract is that the fifth run is the first run. The
+* existing target is carried through verbatim as the base rather than nested under a provenance
+* heading of its own, and a source whose heading is already in that base is left out. That keeps a
+* source restored from an archive from being appended again on a later run.
+*
+* What that skip cannot decide is whether the file is still safe to archive; {@link unmergedSources}
+* answers that from the same sections.
+*/
+function composeConsolidatedInstructions(sources, selection, clusters, model, existingTarget) {
+	const base = existingTarget?.content ?? "";
+	const sections = mergeSections(sources, selection, clusters, model).filter((section) => section.text.trim().length > 0).filter((section) => !base.includes(`${section.heading}\n`)).map((section) => `${section.heading}\n\n${section.text}`);
+	const body = [...base.length === 0 ? [] : [base], ...sections].join("\n\n---\n\n");
+	return body.endsWith("\n") ? body : `${body}\n`;
+}
+/**
+* Selected sources whose current text the merge leaves out, so archiving them would lose it.
+*
+* A section is dropped when its heading is already in the target, which is what stops a restored
+* source from being appended a second time. That is safe only while the target still holds what the
+* file says today: once it has been edited since the merge, the dropped section is the only copy,
+* and the archive consolidation performs would take it off disk without a line of it ever reaching
+* the target. Losing every paragraph to a duplicate winner is not that case — the text is in the
+* target already, under the winner's heading.
+*/
+function unmergedSources(sources, selection, clusters, model, existingTarget) {
+	const base = existingTarget?.content ?? "";
+	return mergeSections(sources, selection, clusters, model).filter((section) => section.text.trim().length > 0 && base.includes(`${section.heading}\n`) && !base.includes(`${section.heading}\n\n${section.text}`)).map((section) => section.path);
+}
+/** The blocks a merge considers, before either caller decides what to do with them. */
+function mergeSections(sources, selection, clusters, model) {
+	const selected = new Set(selection.selectedSources.map((path) => resolve(path)));
+	const removals = loserRanges(selection, clusters);
+	return sources.filter((source) => selected.has(resolve(source.path))).sort((left, right) => left.path.localeCompare(right.path)).map((source) => ({
+		heading: provenanceHeading(source.path, selection.scope, model),
+		path: resolve(source.path),
+		text: removeRanges(source.content, removals.get(resolve(source.path)) ?? [])
+	}));
+}
+/**
+* Names where a merged block came from, without carrying the machine into the file.
+*
+* A project target is committed, so an absolute path there would publish the developer's username
+* and resolve to nothing on anyone else's checkout. The home tilde does the same job for a global
+* target, which is at least private but no more portable.
+*/
+function provenanceHeading(path, scope, model) {
+	const root = scope === "global" ? model.homeDir : model.projectRoot ?? model.cwd;
+	const child = relative(root, path);
+	return `# Instructions from ${child.length > 0 && !child.split(/[\\/]/u).includes("..") ? `${scope === "global" ? "~/" : ""}${child.replaceAll("\\", "/")}` : resolve(path)}`;
+}
+function loserRanges(selection, clusters) {
+	const selected = new Set(selection.selectedSources.map((path) => resolve(path)));
+	const byPath = /* @__PURE__ */ new Map();
+	for (const cluster of clusters) {
+		const members = cluster.members.filter((member) => selected.has(resolve(member.path)));
+		if (members.length < 2) continue;
+		const winner = selection.duplicateWinners[cluster.id] ?? members[0]?.id;
+		for (const member of members) {
+			if (member.id === winner) continue;
+			const path = resolve(member.path);
+			const ranges = byPath.get(path) ?? [];
+			ranges.push(member);
+			byPath.set(path, ranges);
+		}
+	}
+	return byPath;
+}
+function removeRanges(content, ranges) {
+	if (ranges.length === 0) return content;
+	const removed = /* @__PURE__ */ new Set();
+	for (const range of ranges) for (let line = range.startLine; line <= range.endLine; line += 1) removed.add(line);
+	return [...splitSourceLines(content)].filter((line) => !removed.has(line.number)).map((line) => `${line.text}${line.ending}`).join("");
+}
+//#endregion
 //#region src/setup/instructions.ts
 function instructionTargets(model) {
 	return {
@@ -12039,8 +12503,7 @@ function instructionInventory(model) {
 /** How much text one source carries, measured only for the sources a form actually shows. */
 function describeInstructionSource(source) {
 	const lineCount = [...splitSourceLines(source.content)].length;
-	const size = Buffer$1.byteLength(source.content, "utf8");
-	return `${String(lineCount)} lines, ${String(size)} bytes`;
+	return `${String(lineCount)} ${pluralize(lineCount, "line")}`;
 }
 function instructionTargetSource(model, scope, path) {
 	const content = scope === "global" && resolve(path) === resolve(model.sharedInstructions.path) ? model.sharedInstructions.content : model.instructionFiles.find((document) => resolve(document.path) === resolve(path))?.content;
@@ -12078,66 +12541,12 @@ function duplicateClusters(findings) {
 		}];
 	}).sort((left, right) => left.id.localeCompare(right.id));
 }
-/**
-* Merges the selected sources into what the target should contain.
-*
-* Convergent by construction, because setup's contract is that the fifth run is the first run. The
-* existing target is carried through verbatim as the base rather than nested under a provenance
-* heading of its own, and a source whose heading is already in that base is left out: without both,
-* keeping the originals in place means every re-run appends the same guidance one level deeper.
-*/
-function composeConsolidatedInstructions(sources, selection, clusters, model, existingTarget) {
-	const selected = new Set(selection.selectedSources.map((path) => resolve(path)));
-	const removals = loserRanges(selection, clusters);
-	const base = existingTarget?.content ?? "";
-	const sections = sources.filter((source) => selected.has(resolve(source.path))).sort((left, right) => left.path.localeCompare(right.path)).map((source) => ({
-		heading: provenanceHeading(source.path, selection.scope, model),
-		text: removeRanges(source.content, removals.get(resolve(source.path)) ?? [])
-	})).filter((section) => section.text.trim().length > 0).filter((section) => !base.includes(`${section.heading}\n`)).map((section) => `${section.heading}\n\n${section.text}`);
-	const body = [...base.length === 0 ? [] : [base], ...sections].join("\n\n---\n\n");
-	return body.endsWith("\n") ? body : `${body}\n`;
-}
-/**
-* Names where a merged block came from, without carrying the machine into the file.
-*
-* A project target is committed, so an absolute path there would publish the developer's username
-* and resolve to nothing on anyone else's checkout. The home tilde does the same job for a global
-* target, which is at least private but no more portable.
-*/
-function provenanceHeading(path, scope, model) {
-	const root = scope === "global" ? model.homeDir : model.projectRoot ?? model.cwd;
-	const child = relative(root, path);
-	return `# Instructions from ${child.length > 0 && !child.split(/[\\/]/u).includes("..") ? `${scope === "global" ? "~/" : ""}${child.replaceAll("\\", "/")}` : resolve(path)}`;
-}
 function archiveRelativePath(path, scope, model) {
 	const root = scope === "global" ? model.homeDir : model.projectRoot ?? model.cwd;
 	const child = relative(root, path);
 	if (child.length === 0 || child.split(/[\\/]/u).some((part) => part === "..")) return;
 	return `${scope === "global" ? "home" : "project"}/${child.replaceAll("\\", "/")}`;
 }
-function loserRanges(selection, clusters) {
-	const selected = new Set(selection.selectedSources.map((path) => resolve(path)));
-	const byPath = /* @__PURE__ */ new Map();
-	for (const cluster of clusters) {
-		const members = cluster.members.filter((member) => selected.has(resolve(member.path)));
-		if (members.length < 2) continue;
-		const winner = selection.duplicateWinners[cluster.id] ?? members[0]?.id;
-		for (const member of members) {
-			if (member.id === winner) continue;
-			const path = resolve(member.path);
-			const ranges = byPath.get(path) ?? [];
-			ranges.push(member);
-			byPath.set(path, ranges);
-		}
-	}
-	return byPath;
-}
-function removeRanges(content, ranges) {
-	if (ranges.length === 0) return content;
-	const removed = /* @__PURE__ */ new Set();
-	for (const range of ranges) for (let line = range.startLine; line <= range.endLine; line += 1) removed.add(line);
-	return [...splitSourceLines(content)].filter((line) => !removed.has(line.number)).map((line) => `${line.text}${line.ending}`).join("");
-}
 function parseMember(value) {
 	if (!isRecord(value) || typeof value["path"] !== "string" || typeof value["startLine"] !== "number" || typeof value["endLine"] !== "number") return [];
 	const path = resolve(value["path"]);
@@ -12154,13 +12563,6 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region src/setup/managed-apps.ts
-/** Managed ids from this wizard pass, falling back to the persisted selection for targeted runs. */
-function managedAppIdList(context) {
-	if (context.selections.apps !== void 0) return context.selections.apps.managed;
-	return context.manifest.status === "ready" ? Object.entries(context.manifest.value.apps).filter(([, app]) => app.managed).map(([id]) => id) : [];
-}
-//#endregion
 //#region src/setup/instruction-planner.ts
 /**
 * Mode for an instruction file Aura composes.
@@ -12236,11 +12638,12 @@ function planScope(context, selection, inventory, clusters, state) {
 		return false;
 	}
 	planConsolidatedTarget(context, selection, existing, content, state);
-	planOriginals(context, selection, chosen, state);
+	planOriginals(context, selection, chosen, new Set(unmergedSources(chosen, selection, clusters, context.model, existing)), state);
 	return true;
 }
 function planConsolidatedTarget(context, selection, existing, content, state) {
-	if (existing !== void 0 && selection.archiveOriginals) {
+	if (existing !== void 0) {
+		if (existing.content === content) return;
 		const relativePath = archiveRelativePath(existing.path, selection.scope, context.model);
 		if (relativePath === void 0) state.blockers.push({
 			path: existing.path,
@@ -12264,17 +12667,21 @@ function planConsolidatedTarget(context, selection, existing, content, state) {
 	});
 }
 /**
-* Decides what happens to the files the merged text came from.
+* Archives the sources the merged text came from, and leaves behind the ones it did not.
 *
-* A source left in place produces no manual step. Keeping originals is the default answer, so a
-* line per untouched file would appear on every run forever — including the converged one, where
-* "Steps to take yourself" would name work nobody has to do. What that choice actually leaves
-* behind is guidance living in two places, and INS-003 reports exactly that against what is on disk
-* once setup ends on green.
+* Consolidation is a migration, so a source that reached the target is backed up and taken off disk
+* in the same plan, before app links replace or remove what is left. A source the merge left out is
+* the one case where that would delete the only copy of what the file says: its heading is already
+* in the target, so nothing new was appended, and the text on disk is not text the target holds. It
+* stays where it is and the run names it. That step repeats until the divergence is resolved, which
+* is work someone does have to do — unlike a line per untouched file on a converged machine.
 */
-function planOriginals(context, selection, chosen, state) {
-	if (!selection.archiveOriginals) return;
+function planOriginals(context, selection, chosen, unmerged, state) {
 	for (const source of chosen) {
+		if (unmerged.has(resolve(source.path))) {
+			state.manualSteps.push(`${source.path} changed since Aura merged it into ${selection.targetPath}, so Aura left the file in place rather than archiving text the target does not have. Move what is new into ${selection.targetPath}, then delete ${source.path}.`);
+			continue;
+		}
 		const relativePath = archiveRelativePath(source.path, source.scope, context.model);
 		if (relativePath === void 0) state.blockers.push({
 			path: source.path,
@@ -12286,35 +12693,6 @@ function planOriginals(context, selection, chosen, state) {
 		});
 	}
 }
-function planLinks$1(context, scopeSelections, archived, ownership, manualSteps) {
-	const managedIds = new Set(managedAppIdList(context));
-	const operations = [];
-	for (const app of context.model.apps) {
-		if (app.synthetic === true || !managedIds.has(app.adapterId)) continue;
-		operations.push(...planAppLinks(context, app, scopeSelections, archived, ownership, manualSteps));
-	}
-	return operations;
-}
-function planAppLinks(context, app, scopeSelections, archived, ownership, manualSteps) {
-	return scopeSelections.flatMap((selection) => {
-		const link = selection.scope === "global" ? app.sharedLink : app.projectSharedLink;
-		if (link === void 0) return [];
-		const outcome = planSharedInstructionLink(app, context.model, {
-			link,
-			...archived.has(resolve(link.entryPath)) ? { sourceContent: "" } : {},
-			symlinkTarget: selection.targetPath
-		});
-		if ("blocked" in outcome) {
-			manualSteps.push(`Aura could not wire ${link.entryPath}: ${outcome.blocked}`);
-			return [];
-		}
-		manualSteps.push(...outcome.plan.manualSteps ?? []);
-		const files = ownership.get(app.adapterId) ?? [];
-		files.push(link.entryPath);
-		ownership.set(app.adapterId, files);
-		return [...outcome.plan.operations];
-	});
-}
 function primaryPath(operation) {
 	return operation.type === "move" ? operation.sourcePath : operation.path;
 }
@@ -12913,6 +13291,7 @@ function desiredManifest(state, apps, appCatalog, ownershipUpdates, snippets, sk
 	const repo = context.repoPreset;
 	return repo?.accepted === true ? withTrustedRepoPreset(withPreset, {
 		hash: repo.hash,
+		...repo.mainWorktreePath === void 0 ? {} : { mainWorktreePath: repo.mainWorktreePath },
 		path: repo.path
 	}) : withPreset;
 }
@@ -13034,6 +13413,7 @@ async function runPass(request, steps, stepContext, scan, start, activeChecks, c
 	const gathered = await gatherSelections(steps, stepContext, io, start);
 	if (gathered.status === "invalid-dependency") {
 		request.stderr.write(`${branding.displayName}: the ${safe(gathered.stepTitle)} step needs ${safe(gathered.missing)}. Run ${branding.command} setup to establish it, then retry this command.\n`);
+		if (stepContext.repoPreset?.recorded === true) stdout.write(leftUnchanged(stepContext));
 		return {
 			code: 2,
 			kind: "exit",
@@ -13041,7 +13421,7 @@ async function runPass(request, steps, stepContext, scan, start, activeChecks, c
 		};
 	}
 	if (gathered.status === "aborted") {
-		stdout.write("\nLeft everything as it was.\n");
+		stdout.write(leftUnchanged(stepContext));
 		return {
 			code: 1,
 			kind: "exit",
@@ -13053,18 +13433,24 @@ async function runPass(request, steps, stepContext, scan, start, activeChecks, c
 		...stepContext,
 		selections
 	});
-	if (planned.kind === "converged") return {
-		code: endOnGreen(request, scan, activeChecks, config),
-		kind: "exit",
-		manifest: planned.manifest,
-		outcome: "converged"
-	};
-	if (planned.kind === "blocked") return {
-		code: 2,
-		kind: "exit",
-		manifest: planned.manifest,
-		outcome: "blocked"
-	};
+	if (planned.kind === "converged") {
+		if (stepContext.repoPreset?.recorded === true) stdout.write(leftUnchanged(stepContext));
+		return {
+			code: endOnGreen(request, scan, activeChecks, config),
+			kind: "exit",
+			manifest: planned.manifest,
+			outcome: "converged"
+		};
+	}
+	if (planned.kind === "blocked") {
+		if (stepContext.repoPreset?.recorded === true) stdout.write(leftUnchanged(stepContext));
+		return {
+			code: 2,
+			kind: "exit",
+			manifest: planned.manifest,
+			outcome: "blocked"
+		};
+	}
 	if (request.dryRun) {
 		stdout.write("\nDry run: nothing was written.\n");
 		return {
@@ -13088,7 +13474,7 @@ async function runPass(request, steps, stepContext, scan, start, activeChecks, c
 		}
 	};
 	if (confirmation !== "accepted") {
-		stdout.write("\nLeft everything as it was.\n");
+		stdout.write(leftUnchanged(stepContext));
 		return confirmation === "aborted" ? {
 			code: 1,
 			kind: "exit",
@@ -13107,6 +13493,15 @@ async function runPass(request, steps, stepContext, scan, start, activeChecks, c
 		prepared: planned.prepared
 	};
 }
+/**
+* The closing line for a pass that applied nothing.
+*
+* A run that recorded repository preset trust during boot did write one file, and "left everything
+* as it was" is the one sentence a user checks against their own filesystem.
+*/
+function leftUnchanged(stepContext) {
+	return stepContext.repoPreset?.recorded === true ? `\nRecorded your trust of ${AURA_TEAM_PRESET_PATH}. Left everything else as it was.\n` : "\nLeft everything as it was.\n";
+}
 /** Plans the gathered selections, renders the summary, and classifies what can happen next. */
 async function previewPlan(request, inputs) {
 	const { stdout } = request;
@@ -13125,7 +13520,8 @@ async function previewPlan(request, inputs) {
 	stdout.write("\n");
 	renderSetupSummary(prepared.preview, outcome.blockers, outcome.notices, request.withDetail, stdout);
 	if (prepared.preview.conflictedOperationCount > 0 || outcome.blockers.length > 0) {
-		request.stderr.write(`${request.branding.displayName}: the plan is blocked by the current state of these files; nothing was changed.\n`);
+		const recorded = inputs.repoPreset?.recorded === true;
+		request.stderr.write(`${request.branding.displayName}: the plan is blocked by the current state of these files; ${recorded ? "the repository preset trust record was the only change" : "nothing was changed"}.\n`);
 		return {
 			kind: "blocked",
 			manifest: outcome.manifest
@@ -13929,7 +14325,6 @@ function scopeStages(input) {
 	const fallback = options[0]?.value ?? "template";
 	const actionId = `${input.scope}-instruction-action`;
 	const sourcesId = `${input.scope}-instruction-sources`;
-	const archiveId = `${input.scope}-archive-originals`;
 	const draft = (state) => state[input.scope];
 	const update = (state, patch) => ({
 		...state,
@@ -13981,27 +14376,6 @@ function scopeStages(input) {
 				const questions = duplicateQuestions(input.scope, relevant, input.sources, draft(state).duplicateWinners ?? {});
 				return questions.length === 0 ? void 0 : questions;
 			}
-		},
-		{
-			isApplicable: consolidating,
-			label: "Archive",
-			apply: (state, answers) => update(state, { archiveOriginals: selectedValues(answers[archiveId]).includes("archive") }),
-			questions: (state) => consolidating(state) ? [{
-				id: archiveId,
-				initial: [draft(state).archiveOriginals === true ? "archive" : "keep"],
-				kind: "select",
-				label: "Archive",
-				options: [{
-					description: "Leave every original source in place after creating the shared file.",
-					label: "Keep originals in place",
-					value: "keep"
-				}, {
-					description: "Preserve exact originals in Aura's undo journal, then replace or remove them.",
-					label: "Archive originals",
-					value: "archive"
-				}],
-				prompt: "What should Aura do with the selected originals after consolidation?"
-			}] : void 0
 		}
 	];
 }
@@ -14034,12 +14408,12 @@ function actionOptions(input) {
 		value: "keep"
 	});
 	if (input.sources.length > 0) options.push({
-		description: "Merge selected sources with provenance and optional archival.",
-		label: "Consolidate found instructions",
+		description: `Move instructions from the files you select into this ${basename(input.targetPath)} file. Aura backs up the originals for undo.`,
+		label: "Combine found instructions",
 		value: CONSOLIDATE_VALUE
 	});
 	options.push({
-		description: "Start with Aura's minimal official instruction template.",
+		description: `Create this ${basename(input.targetPath)} file with Aura's basic instructions.`,
 		label: "Use starter template",
 		value: TEMPLATE_VALUE
 	});
@@ -14055,10 +14429,10 @@ function actionOptions(input) {
 /**
 * The instructions step: one back-navigable chain of forms across both scopes.
 *
-* Each scope contributes action → sources → duplicate review → archive stages; a stage whose
-* precondition no longer holds (a non-consolidate action, no duplicated paragraphs left) simply
-* disappears from the chain. The chain runner owns ← navigation between the forms and re-seeds
-* re-asked questions with their previous answers.
+* Each scope contributes action → sources → duplicate review stages; a stage whose precondition no
+* longer holds (a non-consolidate action, no duplicated paragraphs left) simply disappears from
+* the chain. The chain runner owns ← navigation between the forms and re-seeds re-asked questions
+* with their previous answers.
 */
 const instructionsStep = {
 	gather: async (context, io) => {
@@ -14118,11 +14492,9 @@ function scopeSelection(input, draft) {
 	if (draft.action !== "consolidate") return inactiveSelection(input, inactiveAction(draft.action, input.scope));
 	const selectedSources = draft.selectedSources ?? [];
 	const relevant = relevantDuplicateClusters(selectedSources, input.clusters);
-	const duplicateWinners = Object.fromEntries(Object.entries(draft.duplicateWinners ?? {}).filter(([id]) => relevant.some((cluster) => cluster.id === id)));
 	return {
 		action: "consolidate",
-		archiveOriginals: draft.archiveOriginals === true,
-		duplicateWinners,
+		duplicateWinners: Object.fromEntries(Object.entries(draft.duplicateWinners ?? {}).filter(([id]) => relevant.some((cluster) => cluster.id === id))),
 		scope: input.scope,
 		selectedSources,
 		targetPath: input.targetPath
@@ -14142,7 +14514,6 @@ function inactiveAction(action, scope) {
 function inactiveSelection(input, action) {
 	return {
 		action,
-		archiveOriginals: false,
 		duplicateWinners: {},
 		scope: input.scope,
 		selectedSources: [],
@@ -14161,7 +14532,6 @@ function toDraft(selection) {
 	if (selection === void 0 || selection.action === "blocked") return {};
 	return {
 		action: selection.action,
-		archiveOriginals: selection.archiveOriginals,
 		duplicateWinners: selection.duplicateWinners,
 		selectedSources: selection.action === "consolidate" ? selection.selectedSources : void 0
 	};
@@ -15391,9 +15761,11 @@ function selectSetupSteps(addKind) {
 * The `setup` flow: scan, gather selections, plan, confirm once, apply, end on green.
 *
 * Steps never write and the plan applies through the fix-plan kernel after one confirmation, so
-* backing out anywhere before that leaves the filesystem untouched by construction. A machine that
-* already matches the desired state produces an empty operation plan and skips both confirmation
-* and the journal — the fifth run is the first run.
+* backing out anywhere before that leaves the filesystem as the run found it — with one exception:
+* an accepted repository preset trust is recorded during boot, because consent the user has already
+* given should not be discarded by a change of mind about the wizard. The closing line names it
+* when that happened. A machine that already matches the desired state produces an empty operation
+* plan and skips both confirmation and the journal — the fifth run is the first run.
 */
 async function runSetup(request) {
 	const { branding, environment, io, stdout } = request;
@@ -15433,7 +15805,7 @@ async function runSetup(request) {
 		registry: request.registry
 	});
 	const preset = setupPresetContext(request, configured.config, configured.preset);
-	const repoPreset = setupRepoPresetContext(configured, booted.acceptedRepoPresetHash);
+	const repoPreset = booted.repoPreset;
 	const stepContext = {
 		appCatalog: buildAppCatalog(request.registry.adapters, model, scan.skipped),
 		...initialFindings === void 0 ? {} : { findings: initialFindings },