@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/cli/targets.ts

@@ -1003,6 +1003,7 @@ function formatUrl(status: TargetStatus): string {
 
 function formatAuth(providers: ProvidersContract, status: TargetStatus): string {
 	if (!status.runtime) return "-";
+	if (status.runtime.externalAgentLoop !== undefined && status.runtime.auth !== "claude-cli") return "operator session";
 	if (status.runtime.auth !== "api-key" && status.runtime.auth !== "oauth") return status.runtime.auth;
 	const auth = providers.auth.statusForTarget(status.target, status.runtime);
 	if (!auth.available) return "disconnected";
@@ -1138,6 +1139,7 @@ interface SerializedStatus {
 	probeNotes?: TargetStatus["probeNotes"];
 	probeSurfaces?: TargetStatus["probeSurfaces"];
 	discoveredModels: TargetStatus["discoveredModels"];
+	discoveredModelLabels?: TargetStatus["discoveredModelLabels"];
 	discoveredModelsSource?: TargetStatus["discoveredModelsSource"];
 	discoveredModelStates?: TargetStatus["discoveredModelStates"];
 	tier: ProviderOutputTier;
@@ -1165,6 +1167,7 @@ function serializeStatus(
 		detectedReasoning: extras.detectedReasoning,
 		reasoningCandidateModelId: extras.candidateModelId,
 	};
+	if (status.discoveredModelLabels !== undefined) out.discoveredModelLabels = status.discoveredModelLabels;
 	const endpointCapacity = endpointCapacityForStatus(status);
 	if (endpointCapacity !== null) out.endpointCapacity = endpointCapacity;
 	if (status.contextWindowProvenance !== undefined) {

package/src/cli/tasks.ts

@@ -0,0 +1,84 @@
+import { normalizeIntentExpectedOutputs, normalizeIntentVerification } from "../domains/dispatch/intent.js";
+import type { UserTaskAcceptance } from "../domains/user-tasks/acceptance.js";
+import { createUserTasksStore } from "../domains/user-tasks/store.js";
+import { packageDeclaredCheck } from "../tools/verify/catalog.js";
+import { discoverDeclaredChecksAtRoot, discoverDeclaredProjectEntriesAtRoot } from "../tools/verify/scripts.js";
+import { printError } from "./argv.js";
+
+/** Operator flags use the same bounds and normalization as dispatch intent. */
+export function acceptanceFromTaskFlags(
+	cwd: string,
+	expectedOutputs: string[],
+	verify: string[],
+): UserTaskAcceptance | undefined {
+	if (expectedOutputs.length === 0 && verify.length === 0) return undefined;
+	const discovery = discoverDeclaredChecksAtRoot(cwd, undefined);
+	if (!discovery.ok) throw new Error(discovery.reason);
+	const checks = new Map(
+		discovery.sources.flatMap((source) => source.checks.map((check) => [check.id, check] as const)),
+	);
+	for (const entry of discoverDeclaredProjectEntriesAtRoot(cwd)) {
+		if (entry.kind === "package-script" && !checks.has(entry.id))
+			checks.set(entry.id, packageDeclaredCheck(entry.id, entry.path, ".", []));
+	}
+	const verification = verify.map((value) => {
+		const suffix = checks.has(value) ? null : /^(.*):([0-9]+)$/.exec(value);
+		const check = suffix?.[1] ?? value;
+		if (!checks.has(check))
+			throw new Error(
+				`Unknown verification check '${check}'. Known ids: ${[...checks.keys()].sort().join(", ") || "(none)"}`,
+			);
+		return { check, ...(suffix ? { timeout_ms: Number(suffix[2]) } : {}) };
+	});
+	const outputs = normalizeIntentExpectedOutputs(expectedOutputs);
+	if (!Array.isArray(outputs)) throw new Error(outputs.ok ? "invalid expected outputs" : outputs.message);
+	const normalized = normalizeIntentVerification(verification, checks);
+	if (!Array.isArray(normalized)) throw new Error(normalized.ok ? "invalid verification" : normalized.message);
+	return { expectedOutputs: outputs, verification: normalized };
+}
+
+const HELP = `Usage:
+  clio-coder tasks [list]
+  clio-coder tasks add [--expect <path>] [--verify <checkId>[:timeoutMs]] <text>
+  clio-coder tasks hand|done|drop <uN>
+
+--expect and --verify are repeatable. Check ids must be declared in package.json or .clio-coder/verifiers.yaml.`;
+
+export function runTasksCommand(args: string[]): number {
+	try {
+		if (args.includes("--help") || args.includes("-h")) {
+			console.log(HELP);
+			return 0;
+		}
+		const store = createUserTasksStore({ cwd: process.cwd() });
+		const [action = "list", ...rest] = args;
+		if (action === "add") {
+			const expected: string[] = [],
+				verify: string[] = [],
+				title: string[] = [];
+			for (let index = 0; index < rest.length; index++) {
+				const token = rest[index] ?? "";
+				if (token === "--") {
+					title.push(...rest.slice(index + 1));
+					break;
+				}
+				if (token === "--expect" || token === "--verify") {
+					const value = rest[++index];
+					if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+					(token === "--expect" ? expected : verify).push(value);
+				} else if (token.startsWith("--")) throw new Error(`Unknown flag ${token}`);
+				else title.push(token);
+			}
+			const task = store.add(title.join(" "), undefined, acceptanceFromTaskFlags(process.cwd(), expected, verify));
+			console.log(`logged operator task ${task.id}: ${task.title}`);
+		} else if (action === "list" && rest.length === 0) {
+			console.log(JSON.stringify(store.snapshot(), null, 2));
+		} else if ((action === "hand" || action === "done" || action === "drop") && rest.length === 1) {
+			console.log(JSON.stringify(store[action](rest[0] ?? ""), null, 2));
+		} else throw new Error(HELP);
+		return 0;
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}

package/src/cli/uninstall.ts

@@ -5,38 +5,50 @@ import { delimiter, dirname, isAbsolute, join, resolve, sep } from "node:path";
 
 import { resolvePackageRoot } from "../core/package-root.js";
 import { resetXdgCache, resolveClioDirs } from "../core/xdg.js";
+import { detectInstallMethod } from "../domains/lifecycle/install-method.js";
+import { createLifecyclePresenter, type LifecycleItem, measurePath, shortenPath } from "./lifecycle-presenter.js";
 import { type RemovalFailure, removePath, reportRemovalFailures } from "./removal.js";
-import { printError, printHeader, printOk } from "./shared.js";
+import { printError } from "./shared.js";
 
-const HELP = `clio-coder uninstall [--remove-binary] [--dry-run] [--force]
+const HELP = `clio-coder uninstall [--remove-binary] [--keep-config] [--keep-data] [--dry-run] [--force] [--json]
 
 Remove all Clio Coder state: the config, data, state, and cache roots.
 
-Per-project \`.clio-coder/\` directories are outside those roots and are never removed
-here. Every project Clio has run in is recorded in the session metadata, so both
-the real run and --dry-run list them and name the command that clears one,
-before the launcher is touched.
+Per-project \`.clio-coder/\` directories sit outside those roots and are never
+removed here. Every project Clio has run in is recorded in the session metadata,
+so the real run and --dry-run both list them and name the command that clears one.
+Shell startup files are reported, never edited.
 
 Flags:
+  --keep-config    preserve the configuration root (settings.yaml, credentials)
+  --keep-data      preserve the data root (memory, evidence, vendored tools)
   --remove-binary  also remove the launcher symlink when it points at this
                    installation. A real file, or a link into a different clio-coder
                    installation, is kept and reported.
   --dry-run        print what would be removed without changing anything
-  --force          required for destructive execution
+  --force, -f      skip confirmation prompt and proceed immediately
+  --json           emit machine-readable JSON output
+  --help, -h       show this message
 `;
 
 interface ParsedUninstallArgs {
 	removeBinary: boolean;
+	keepConfig: boolean;
+	keepData: boolean;
 	force: boolean;
 	dryRun: boolean;
+	json: boolean;
 	help: boolean;
 }
 
 function parseUninstallArgs(argv: ReadonlyArray<string>): ParsedUninstallArgs {
 	const parsed: ParsedUninstallArgs = {
 		removeBinary: false,
+		keepConfig: false,
+		keepData: false,
 		force: false,
 		dryRun: false,
+		json: false,
 		help: false,
 	};
 	for (const arg of argv) {
@@ -44,6 +56,12 @@ function parseUninstallArgs(argv: ReadonlyArray<string>): ParsedUninstallArgs {
 			case "--remove-binary":
 				parsed.removeBinary = true;
 				break;
+			case "--keep-config":
+				parsed.keepConfig = true;
+				break;
+			case "--keep-data":
+				parsed.keepData = true;
+				break;
 			case "--force":
 			case "-f":
 				parsed.force = true;
@@ -51,6 +69,9 @@ function parseUninstallArgs(argv: ReadonlyArray<string>): ParsedUninstallArgs {
 			case "--dry-run":
 				parsed.dryRun = true;
 				break;
+			case "--json":
+				parsed.json = true;
+				break;
 			case "--help":
 			case "-h":
 				parsed.help = true;
@@ -62,10 +83,6 @@ function parseUninstallArgs(argv: ReadonlyArray<string>): ParsedUninstallArgs {
 	return parsed;
 }
 
-function report(label: string, path: string): void {
-	process.stdout.write(`  ${label.padEnd(8)} remove ${path}${existsSync(path) ? "" : "  (absent)"}\n`);
-}
-
 export interface ProjectContextInventory {
 	/** Project directories the session store recorded, one per cwd hash. */
 	recorded: number;
@@ -78,17 +95,6 @@ export interface ProjectContextInventory {
 /**
  * The projects Clio has run in, read from the session metadata under
  * `<stateDir>/sessions/`.
- *
- * Uninstall removes four roots under the home directory and nothing else, so
- * every `.clio-coder/` it ever wrote inside a repository survived it, unlisted. The
- * operator was left to remember which repositories those were, after the
- * command that could have told them had deleted the record and, with
- * `--remove-binary`, the binary that reads it.
- *
- * One `meta.json` per cwd-hash directory is enough: every session under a hash
- * shares the `cwd` that produced it, so this reads one small file per project
- * rather than one per session. Directories whose `.clio-coder/` is already gone are
- * dropped, because an inventory of nothing to do is noise.
  */
 function projectContextInventory(stateDir: string): ProjectContextInventory {
 	const root = join(stateDir, "sessions");
@@ -129,37 +135,6 @@ function firstRecordedCwd(hashDir: string): string | null {
 	return null;
 }
 
-/**
- * Print the project inventory and the command that clears one.
- *
- * Ordering is the point. This runs before the roots are removed, because the
- * record it reads is inside one of them, and before the launcher is removed,
- * because `clio-coder context reset --all` needs the binary that is about to go.
- */
-function reportProjectContext(inventory: ProjectContextInventory, removeBinary: boolean): void {
-	process.stdout.write("\nPer-project context (not removed by uninstall):\n");
-	if (inventory.storeAbsent) {
-		process.stdout.write("  no session store to read; any .clio-coder/ directories must be found by hand\n");
-		return;
-	}
-	if (inventory.dirs.length === 0) {
-		process.stdout.write(
-			`  none: ${inventory.recorded} project director${inventory.recorded === 1 ? "y" : "ies"} recorded, none still has a .clio-coder/\n`,
-		);
-		return;
-	}
-	for (const dir of inventory.dirs) process.stdout.write(`  ${join(dir, ".clio-coder")}\n`);
-	// The cleaner is a clio subcommand, so with --remove-binary this run is
-	// taking the thing that would have run it. Saying "clear these first" after
-	// the launcher is already gone would be advice the operator cannot follow.
-	process.stdout.write(
-		removeBinary
-			? "\nThis run also removes the launcher. Clear each one from inside it first, then re-run:\n"
-			: "\nClear each one from inside it, while clio still runs:\n",
-	);
-	process.stdout.write("  clio-coder context reset --all\n\n");
-}
-
 function launcherLinkPath(): string {
 	const binDir = process.env.CLIO_CODER_BIN_DIR?.trim() || join(homedir(), ".local", "bin");
 	return join(binDir, "clio-coder");
@@ -171,32 +146,12 @@ function ownedCliEntry(): string {
 	try {
 		return realpathSync(entry);
 	} catch {
-		// A source checkout with no build yet, or a dist this process was not
-		// launched from. The unresolved path is still the right identity.
 		return entry;
 	}
 }
 
 type LauncherVerdict = { kind: "absent" } | { kind: "keep"; detail: string } | { kind: "remove"; detail: string };
 
-/**
- * Decide whether the launcher at `linkPath` belongs to this installation.
- *
- * Ownership is identity, not shape. The previous rule accepted any symlink
- * whose target path ended in `dist/cli/index.js`, which is a string test three
- * ways too broad: it matched a live symlink into a *different* clio checkout,
- * and it matched a target that is not even a file, so `clio-coder uninstall
- * --remove-binary` from one installation would silently unlink another one's
- * launcher and leave that installation on disk with no way to start it.
- *
- * A link that resolves to this installation's own entry is ours and goes. A
- * link that resolves anywhere else is somebody's, so it stays with the path it
- * points at and the command that removes it deliberately. A dangling link is
- * the one case with no owner to defer to: the installation it named is gone,
- * unlinking it cannot touch a target that does not exist, and leaving it puts
- * a broken `clio-coder` on PATH after an uninstall that claimed to finish. Those are
- * removed when the name they carry is a clio entry, and reported as dangling.
- */
 function classifyLauncher(linkPath: string): LauncherVerdict {
 	let isSymlink: boolean;
 	try {
@@ -235,25 +190,6 @@ function classifyLauncher(linkPath: string): LauncherVerdict {
 	};
 }
 
-/** Returns the failure when the owned launcher existed but could not be unlinked. */
-function removeLauncher(dryRun: boolean): RemovalFailure | null {
-	const linkPath = launcherLinkPath();
-	const verdict = classifyLauncher(linkPath);
-	if (verdict.kind === "absent") {
-		process.stdout.write(`  binary   absent ${linkPath}\n`);
-		return null;
-	}
-	if (verdict.kind === "keep") {
-		process.stdout.write(`  binary   keep   ${linkPath} (${verdict.detail})\n`);
-		return null;
-	}
-	process.stdout.write(`  binary   remove ${linkPath} ${verdict.detail}\n`);
-	// Shares removePath so the launcher gets the same unlink-the-link handling
-	// every other removed path gets. Removing the link with `rmSync` left a
-	// dangling one in place while reporting that it had gone.
-	return removePath("binary", linkPath, dryRun);
-}
-
 function findClioOnPath(): string | null {
 	const names =
 		process.platform === "win32" ? ["clio-coder.cmd", "clio-coder.ps1", "clio-coder.exe", "clio-coder"] : ["clio-coder"];
@@ -273,11 +209,6 @@ function readNpmPrefix(): string | null {
 			encoding: "utf8",
 			timeout: 5000,
 			stdio: ["ignore", "pipe", "ignore"],
-			// A read-only probe that writes. npm drops a debug log into
-			// $HOME/.npm/_logs on every invocation, so the documented
-			// side-effect-free `--dry-run` path left a file behind in the home
-			// directory it had just finished promising not to touch. `logs-max=0`
-			// keeps npm from retaining any; the notifier is off for the same reason.
 			env: { ...process.env, npm_config_logs_max: "0", npm_config_update_notifier: "false" },
 		});
 		if (result.status !== 0) return null;
@@ -288,16 +219,6 @@ function readNpmPrefix(): string | null {
 	}
 }
 
-/**
- * The `clio` a shell will find, when that is not the launcher this uninstall
- * was about.
- *
- * Both paths are resolved through their symlinks before they are compared: the
- * PATH entry is normally a link into this checkout, and comparing the link to
- * its own target reported two installations where there is one. A PATH entry
- * that cannot be resolved is dangling, which is still something the operator
- * will hit and still not this installation.
- */
 function otherClioOnPath(pathClio: string | null, localLink: string): string | null {
 	if (pathClio === null) return null;
 	if (pathClio === localLink) return null;
@@ -313,93 +234,240 @@ function otherClioOnPath(pathClio: string | null, localLink: string): string | n
 	return pathClio;
 }
 
-function printRemovalGuidance(removeBinaryRequested: boolean): void {
-	const pathClio = findClioOnPath();
-	const npmPrefix = readNpmPrefix();
-	const localLink = launcherLinkPath();
-	const currentLauncher = process.argv[1];
-
-	process.stdout.write("\nBinary removal guidance:\n");
-	if (currentLauncher) process.stdout.write(`  current launcher: ${currentLauncher}\n`);
-	process.stdout.write(`  PATH lookup:      ${pathClio ?? "not currently found"}\n`);
-	if (npmPrefix) process.stdout.write(`  npm prefix bin:   ${join(npmPrefix, "bin")}\n`);
-	process.stdout.write(`  local source bin: ${localLink}${existsSync(localLink) ? "" : "  (absent)"}\n`);
-	// The two lines above are adjacent and were left for the reader to compare.
-	// When they differ they are two installations, and the operator who just read
-	// "removed Clio Coder state" will type `clio-coder` next and reach the other one.
-	// Saying so is the whole point of printing both paths.
-	const survivor = otherClioOnPath(pathClio, localLink);
-	if (survivor !== null) {
-		process.stdout.write(`\nanother clio-coder remains on your PATH at ${survivor}\n`);
-		process.stdout.write("  it is a different installation from the one this uninstall touched\n");
-		process.stdout.write(`  check it with: ${survivor} --version\n`);
+/**
+ * Shell startup files that mention Clio. Uninstall reports them and never edits
+ * them: a login file is the user's own, an installer is not the only thing that
+ * writes `clio-coder` into one, and a wrong automated edit costs a working
+ * shell. Naming the file and leaving the edit to the operator is the honest
+ * trade, so these rows are listed as kept rather than as removals.
+ */
+function detectShellRcEdits(): string[] {
+	const candidates = [join(homedir(), ".bashrc"), join(homedir(), ".zshrc"), join(homedir(), ".profile")];
+	const results: string[] = [];
+	for (const file of candidates) {
+		try {
+			const content = readFileSync(file, "utf8");
+			if (content.includes("clio-coder") || content.includes("CLIO_CODER")) results.push(file);
+		} catch {
+			// Absent or unreadable says nothing to report.
+		}
 	}
-	process.stdout.write("\nUse the removal path that matches how you installed Clio Coder:\n");
-	// Re-suggesting the flag the operator just passed reads as though it had not
-	// run, so the source-symlink line only appears when it is still an option.
-	if (!removeBinaryRequested) {
-		process.stdout.write("  source symlink:  clio-coder uninstall --remove-binary --force\n");
+	return results;
+}
+
+/**
+ * The one fact worth a line after the roots are gone: a second clio-coder that
+ * this uninstall did not touch is still first on PATH, so the next `clio-coder`
+ * runs it and the operator would conclude the uninstall failed.
+ */
+function survivingClioOnPath(localLink: string): string | null {
+	return otherClioOnPath(findClioOnPath(), localLink);
+}
+
+/**
+ * How the launcher row reads. `--remove-binary` promises to unlink only a
+ * symlink into this installation; every other shape is kept, and saying so on
+ * the inventory is the difference between an operator who knows a launcher
+ * survived and one who finds out from the next `clio-coder`.
+ */
+function launcherItemStatus(verdict: LauncherVerdict, removeRequested: boolean): LifecycleItem["status"] {
+	if (verdict.kind === "absent") return "absent";
+	if (verdict.kind === "keep") return "skip";
+	return removeRequested ? "remove" : "skip";
+}
+
+function launcherItemDetail(verdict: LauncherVerdict, removeRequested: boolean): string | undefined {
+	if (verdict.kind === "absent") return undefined;
+	if (verdict.kind === "keep") return verdict.detail;
+	return removeRequested ? undefined : "kept; --remove-binary unlinks it";
+}
+
+/** The removal command that matches how this installation was put on disk. */
+function binaryRemovalAdvice(method: "source" | "npm", linkPath: string): { lead: string; command: string } {
+	if (method === "npm") {
+		const prefix = readNpmPrefix();
+		return {
+			lead: prefix === null ? "To remove the launcher, run:" : `To remove the launcher from ${join(prefix, "bin")}, run:`,
+			command: "npm uninstall -g @iowarp/clio-coder\nhash -r",
+		};
 	}
-	process.stdout.write("  npm global:      npm uninstall -g @iowarp/clio-coder\n");
-	process.stdout.write("  npm link:        npm unlink -g @iowarp/clio-coder\n");
-	process.stdout.write("\nAfter removing or replacing a clio-coder link, clear shell command caches:\n");
-	process.stdout.write("  hash -r   # Bash\n");
-	process.stdout.write("  rehash    # Zsh\n");
+	return { lead: "To finish removing the launcher, run:", command: `rm "${linkPath}"\nhash -r` };
 }
 
-export function runUninstallCommand(argv: ReadonlyArray<string>): number {
+export async function runUninstallCommand(argv: ReadonlyArray<string>): Promise<number> {
 	let args: ParsedUninstallArgs;
 	try {
 		args = parseUninstallArgs(argv);
 	} catch (error) {
 		printError(error instanceof Error ? error.message : String(error));
-		process.stdout.write(HELP);
+		process.stderr.write(HELP);
 		return 2;
 	}
 	if (args.help) {
 		process.stdout.write(HELP);
 		return 0;
 	}
-	if (!args.dryRun && !args.force) {
-		printError("`clio-coder uninstall` requires --force unless you are using --dry-run");
-		process.stdout.write(HELP);
+
+	// One sentence, and nothing on stdout: a caller that piped this run is
+	// parsing stdout, and a help dump there is indistinguishable from output.
+	const isInteractive = Boolean(process.stdin.isTTY);
+	if (!args.dryRun && !args.force && !isInteractive) {
+		printError("`clio-coder uninstall` needs a terminal to confirm; pass --force to skip the prompt");
 		return 2;
 	}
 
 	const dirs = resolveClioDirs();
-	printHeader("Clio Coder uninstall");
-	const roots = [
-		["config", dirs.config],
-		["data", dirs.data],
-		["state", dirs.state],
-		["cache", dirs.cache],
-	] as const;
-	for (const [label, path] of roots) report(label, path);
-
-	// Read the session store before it is removed and report it before the
-	// launcher is: both halves of that ordering are load-bearing.
-	reportProjectContext(projectContextInventory(dirs.state), args.removeBinary);
-
-	// Every root is attempted even after one fails, so a single unwritable
-	// subtree cannot leave the other three behind unreported.
+	const method = detectInstallMethod();
+	const presenter = createLifecyclePresenter({ json: args.json });
+
+	presenter.header("Uninstall Clio Coder", "uninstall");
+	presenter.step(`Installation method: ${method === "source" ? "source symlink" : "npm global"}`);
+
+	const configSize = measurePath(dirs.config);
+	const dataSize = measurePath(dirs.data);
+	const stateSize = measurePath(dirs.state);
+	const cacheSize = measurePath(dirs.cache);
+	const linkPath = launcherLinkPath();
+	const linkSize = measurePath(linkPath);
+	const launcher = classifyLauncher(linkPath);
+	const shellEdits = detectShellRcEdits();
+
+	// The state root's own children (audit, sessions) are inside the State row
+	// and go with it; listing them again as separate removals double-counted the
+	// bytes and promised per-child results that one recursive delete never
+	// produces.
+	const items: LifecycleItem[] = [
+		{
+			label: "Data",
+			path: dirs.data,
+			bytes: dataSize.bytes,
+			status: args.keepData ? "keep" : dataSize.exists ? "remove" : "absent",
+			detail: args.keepData ? "kept by --keep-data" : undefined,
+		},
+		{
+			label: "Cache",
+			path: dirs.cache,
+			bytes: cacheSize.bytes,
+			status: cacheSize.exists ? "remove" : "absent",
+		},
+		{
+			label: "Config",
+			path: dirs.config,
+			bytes: configSize.bytes,
+			status: args.keepConfig ? "keep" : configSize.exists ? "remove" : "absent",
+			detail: args.keepConfig ? "kept by --keep-config" : undefined,
+		},
+		{
+			label: "State",
+			path: dirs.state,
+			bytes: stateSize.bytes,
+			status: stateSize.exists ? "remove" : "absent",
+			detail: stateSize.exists ? "sessions, audit, receipts" : undefined,
+		},
+		{
+			label: "Launcher",
+			path: linkPath,
+			bytes: linkSize.bytes,
+			status: launcherItemStatus(launcher, args.removeBinary),
+			detail: launcherItemDetail(launcher, args.removeBinary),
+		},
+	];
+
+	// A login file is reported, never edited; see detectShellRcEdits.
+	for (const file of shellEdits) {
+		items.push({ label: "Shell config", path: file, status: "skip", detail: "mentions clio-coder; edit it by hand" });
+	}
+
+	presenter.listItems("The following will be removed", items);
+
+	const projectInv = projectContextInventory(dirs.state);
+	if (projectInv.dirs.length > 0) {
+		presenter.note("Per-project context, which uninstall does not remove:");
+		for (const dir of projectInv.dirs) {
+			presenter.substep(shortenPath(join(dir, ".clio-coder")), "–");
+		}
+		presenter.commandAdvice("To clear one, run inside that project:", "clio-coder context reset --all");
+	}
+
+	// The same guidance on the dry run and on the real run, so the preview is the
+	// listing the run produces and nothing more.
+	const survivor = survivingClioOnPath(linkPath);
+	const advice = binaryRemovalAdvice(method, linkPath);
+
+	if (args.dryRun) {
+		presenter.warn("Dry run: no changes made");
+		if (launcher.kind !== "absent" && !args.removeBinary) presenter.commandAdvice(advice.lead, advice.command);
+		if (survivor !== null)
+			presenter.warn(`Another clio-coder stays on your PATH at ${survivor}; it is a separate install`);
+		presenter.done("Done");
+		return 0;
+	}
+
+	if (!args.force) {
+		const confirmed = await presenter.confirm("Are you sure you want to uninstall?", false);
+		if (!confirmed) {
+			presenter.warn("Uninstall cancelled");
+			presenter.done("Cancelled");
+			return 0;
+		}
+	}
+
 	const failures: RemovalFailure[] = [];
-	for (const [label, path] of roots) {
-		const failure = removePath(label, path, args.dryRun);
+
+	if (cacheSize.exists) {
+		const failure = removePath("cache", dirs.cache, false);
 		if (failure) failures.push(failure);
+		else presenter.completedStep("Removed Cache");
 	}
-	if (args.removeBinary) {
-		const failure = removeLauncher(args.dryRun);
+
+	if (!args.keepData && dataSize.exists) {
+		const failure = removePath("data", dirs.data, false);
 		if (failure) failures.push(failure);
+		else presenter.completedStep("Removed Data");
 	}
+
+	if (!args.keepConfig && configSize.exists) {
+		const failure = removePath("config", dirs.config, false);
+		if (failure) failures.push(failure);
+		else presenter.completedStep("Removed Config");
+	}
+
+	if (stateSize.exists) {
+		const failure = removePath("state", dirs.state, false);
+		if (failure) failures.push(failure);
+		else presenter.completedStep("Removed State");
+	}
+
+	// Only a symlink into this installation is ever unlinked. Reporting the
+	// removal from `--remove-binary` alone announced one for a launcher the
+	// classifier had already decided to keep.
+	let launcherRemoved = false;
+	if (args.removeBinary && launcher.kind === "remove") {
+		const failure = removePath("launcher", linkPath, false);
+		if (failure) failures.push(failure);
+		else {
+			presenter.completedStep("Removed launcher");
+			launcherRemoved = true;
+		}
+	}
+
 	resetXdgCache();
 
 	if (failures.length > 0) {
-		printError("uninstall did not remove everything");
-		reportRemovalFailures(`clio-coder uninstall${args.removeBinary ? " --remove-binary" : ""} --force`, failures);
+		presenter.fail("uninstall did not remove everything");
+		reportRemovalFailures(
+			`clio-coder uninstall${args.removeBinary ? " --remove-binary" : ""}${args.keepConfig ? " --keep-config" : ""}${args.keepData ? " --keep-data" : ""} --force`,
+			failures,
+		);
+		presenter.finish();
 		return 1;
 	}
 
-	printOk(args.dryRun ? "uninstall preview complete" : "removed Clio Coder state");
-	printRemovalGuidance(args.removeBinary);
+	if (launcher.kind !== "absent" && !launcherRemoved) presenter.commandAdvice(advice.lead, advice.command);
+	if (survivor !== null)
+		presenter.warn(`Another clio-coder stays on your PATH at ${survivor}; it is a separate install`);
+
+	presenter.message("Thank you for using Clio Coder.");
+	presenter.done("Done");
 	return 0;
 }