universal-dev-standards 6.14.0-beta.2 → 6.14.0-beta.4

package/src/commands/init.js

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import { createSpinner } from '../utils/spinner.js';
-import { execSync } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
 import { join } from 'path';
 import {
   manifestExists as isInitialized,
@@ -22,13 +21,17 @@ import {
   getAgentConfig,
   getAgentDisplayName
 } from '../utils/github.js';
-import { displayLanguageToLocale } from '../utils/locale.js';
+import { displayLanguageToLocale, normalizeRequestedLocale } from '../utils/locale.js';
+import localeUtils from '../utils/locale.js';
+const LOCALE_MAP_FOR_INIT = localeUtils.LOCALE_MAP;
 import { generateReleaseConfig, RELEASE_MODE_LABELS } from '../utils/release-config.js';
 import { guardAgainstSelfAdoption } from '../utils/detect-self-adoption.js';
 import { readInstallYaml } from '../utils/config-manager.js';
 import { resolveIntegrationTargetFile } from '../utils/integration-generator.js';
 import { withFileTransaction } from '../utils/transaction.js';
-import { wireGitHooksPath, getLocalHooksPathConfig, stripLegacyHuskyShLine, ensureShebang } from '../utils/git-hooks.js';
+import { newRecorder, mkdirTracked, recordFile, persistRecorder, RECORD_KINDS } from '../core/install-records.js';
+import { wireGitHooksPath, getLocalHooksPathConfig, stripLegacyHuskyShLine, ensureShebang, hookRunsUdsCheck, buildPreCommitBlock } from '../utils/git-hooks.js';
+import { migrateLegacyHuskyHook } from '../utils/legacy-hook-migration.js';
 
 /**
  * Init command - initialize standards in current project
@@ -213,7 +216,11 @@ export async function initCommand(options) {
             skillHashes: skillsResults.skillHashes,
             commandHashes: skillsResults.commandHashes,
             integrationBlockHashes: integrationResults.integrationBlockHashes,
-            manifestIntegrationConfigs: integrationResults.manifestIntegrationConfigs
+            manifestIntegrationConfigs: integrationResults.manifestIntegrationConfigs,
+            createdIntegrationFiles: [
+              ...(integrationResults.createdFiles ?? []),
+              ...(agentsMdResult.created ? [agentsMdResult.path] : [])
+            ]
           };
         },
         // A half-installed project must never be committed: if any installer
@@ -258,9 +265,13 @@ export async function initCommand(options) {
   }
 
   // 4.6. Install enforcement hooks (if --with-hooks)
+  // What this step writes is recorded in the manifest (installedArtifacts) so
+  // `uds uninstall` can remove exactly it — hook scripts, and the folders UDS had
+  // to create for them — and leave everything the adopter put there alone.
+  const installRecorder = newRecorder();
   if (config.withHooks) {
     const { installHooks } = await import('../installers/hooks-installer.js');
-    const hookResult = installHooks(projectPath);
+    const hookResult = installHooks(projectPath, { recorder: installRecorder });
     if (hookResult.installed) {
       console.log(chalk.green(
         `  ✓ Enforcement hooks installed (${hookResult.scriptsCount} scripts, `
@@ -292,7 +303,7 @@ export async function initCommand(options) {
     const selectedTools = config.integrations || config.aiTools || [];
     if (selectedTools.includes('codex')) {
       const { installCodexHooks } = await import('../installers/hooks-installer.js');
-      const codexResult = installCodexHooks(projectPath);
+      const codexResult = installCodexHooks(projectPath, { recorder: installRecorder });
       if (codexResult.installed) {
         console.log(chalk.green('  ✓ Codex Stop hook installed (turn-completion-integrity)'));
         // Measured 2026-09-28 (codex-cli 0.155.1): Codex skips a project hook
@@ -306,7 +317,7 @@ export async function initCommand(options) {
     }
     if (selectedTools.includes('gemini-cli')) {
       const { installGeminiHooks } = await import('../installers/hooks-installer.js');
-      const geminiResult = installGeminiHooks(projectPath);
+      const geminiResult = installGeminiHooks(projectPath, { recorder: installRecorder });
       if (geminiResult.installed) {
         console.log(chalk.green('  ✓ Gemini CLI AfterAgent hook installed (turn-completion-integrity; Gemini CLI is legacy — see the standard)'));
       } else {
@@ -315,7 +326,7 @@ export async function initCommand(options) {
     }
     if (selectedTools.includes('antigravity')) {
       const { installAgyHooks } = await import('../installers/hooks-installer.js');
-      const agyResult = installAgyHooks(projectPath);
+      const agyResult = installAgyHooks(projectPath, { recorder: installRecorder });
       if (agyResult.installed) {
         console.log(chalk.green('  ✓ Antigravity CLI Stop hook installed (turn-completion-integrity; .agents/hooks.json)'));
         // Verified 2026-09-29 (agy 1.2.12): single turn, no tool calls, `agy -p`.
@@ -328,6 +339,15 @@ export async function initCommand(options) {
     }
   }
 
+  // 4.7. Record the integration files UDS created from nothing, and the hook
+  // files/folders written above. Their text outside the UDS marker block (the
+  // `> Auto-generated by ...` header, the generated sections) is what makes
+  // "delete the whole file" provable at uninstall time.
+  for (const created of combinedResults.createdIntegrationFiles ?? []) {
+    recordFile(installRecorder, projectPath, created, RECORD_KINDS.INTEGRATION_FILE);
+  }
+  persistRecorder(projectPath, installRecorder);
+
   // 5. Setup Pre-commit Hook
   await setupHuskyHook(projectPath);
 
@@ -339,7 +359,7 @@ export async function initCommand(options) {
  * - Node.js projects: use husky
  * - Non-Node.js projects: write native .git/hooks/pre-commit
  */
-export async function setupHuskyHook(projectPath, { allowInTest = false } = {}) {
+export async function setupHuskyHook(projectPath, { allowInTest = false, platform = process.platform } = {}) {
   // 2026-07-30：本函式在跑測試時改寫了 universal-dev-standards 自己
   // ——`npm install --save-dev husky`、改 package.json、建 .husky/pre-commit。
   //
@@ -359,6 +379,9 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
 
   const isNodeProject = existsSync(join(projectPath, 'package.json'));
 
+  // What this function creates, for `uds uninstall` (see core/install-records.js).
+  const recorder = newRecorder();
+
   if (isNodeProject) {
     console.log(chalk.cyan('Configuring Pre-commit Hook...'));
 
@@ -436,7 +459,7 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
     // 3. Ensure .husky directory exists
     if (!existsSync(huskyDir)) {
       try {
-        mkdirSync(huskyDir, { recursive: true });
+        mkdirTracked(recorder, projectPath, huskyDir);
       } catch (e) {
         console.log(chalk.red(`  ✗ Failed to create .husky directory: ${e.message}`));
         return;
@@ -445,8 +468,10 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
 
     // 4. Add pre-commit hook content
     const preCommitPath = join(huskyDir, 'pre-commit');
-    const udsCmd = 'npx uds check';
 
+    // Only a hook file UDS creates from nothing can later be proven to be wholly
+    // its own; one that already existed is appended to and stays the adopter's.
+    const preCommitExisted = existsSync(preCommitPath);
     try {
       // husky v9's own templates carry no shebang, no `_/husky.sh` sourcing
       // (that is v8 syntax, deprecated in v9 and removed in v10). Verified
@@ -464,6 +489,18 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
       // — cheap, harmless on POSIX, and required on Windows. Existing files
       // are appended to, never rewritten — their contents are the adopter's,
       // not ours; ensureShebang only ever prepends a missing first line.
+      // A hook an older UDS wrote asks npx for the bare name `uds`, which on the
+      // npm registry is an unrelated package (see buildPreCommitBlock). Swap the
+      // line UDS itself wrote for the current block before anything else reads
+      // the file; a line the adopter edited is left alone and reported below.
+      const legacy = existsSync(preCommitPath) ? migrateLegacyHuskyHook(projectPath) : null;
+      if (legacy?.state === 'migrated') {
+        console.log(chalk.green('  ✓ Replaced the pre-commit line an older UDS wrote (it asked npm to resolve the bare name "uds", which is not this project) with one that runs only the installed UDS CLI'));
+      }
+      for (const k of legacy?.kept ?? []) {
+        console.log(chalk.yellow(`  ⚠ .husky/pre-commit line ${k.line} ("${k.text}") asks npm to resolve the bare name "uds", which on the npm registry is an unrelated package. UDS did not write this exact line, so it was left alone — change it to "universal-dev-standards check" (with the CLI installed in this project or on PATH).`));
+      }
+
       let content = existsSync(preCommitPath) ? readFileSync(preCommitPath, 'utf-8') : '';
 
       // A pre-existing file may still carry husky v8's `_/husky.sh` sourcing
@@ -479,10 +516,10 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
       const { content: destripped, removed: hadLegacyLine } = stripLegacyHuskyShLine(content);
       content = destripped;
 
-      const needsAppend = !content.includes('uds check');
+      const needsAppend = !hookRunsUdsCheck(content);
       if (needsAppend) {
         const sep = content && !content.endsWith('\n') ? '\n' : '';
-        content = `${content}${sep}\n# UDS Standard Check\n${udsCmd}\n`;
+        content = `${content}${sep}\n${buildPreCommitBlock()}`;
       }
 
       const { content: shebanged, added: addedShebang } = ensureShebang(content);
@@ -490,10 +527,22 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
 
       if (hadLegacyLine || needsAppend || addedShebang) {
         writeFileSync(preCommitPath, content, 'utf-8');
-        try {
-          execSync(`chmod +x ${preCommitPath}`);
-        } catch {
-          // Ignore chmod failures on systems that don't support it
+        if (!preCommitExisted) recordFile(recorder, projectPath, '.husky/pre-commit', RECORD_KINDS.GIT_HOOK);
+        // 🔴 Was `execSync(`chmod +x ...`)` inside try/catch. On Windows that
+        // spawned cmd.exe, which printed "'chmod' is not recognized as an
+        // internal or external command" straight to the user's terminal —
+        // execSync inherits the child's stderr by default, so the catch hid the
+        // failure from the code and left it loud for the human (adopter report,
+        // 6.14.0-beta.2, Windows 11). No shell is needed to change a mode, and
+        // Windows has no exec bit to set (git for Windows runs the hook through
+        // its own sh regardless), so it is skipped there.
+        if (platform !== 'win32') {
+          try {
+            chmodSync(preCommitPath, 0o755);
+          } catch {
+            // A filesystem that refuses the mode change (FAT, some mounts) is not
+            // a reason to fail the install; git reports a non-executable hook itself.
+          }
         }
       }
 
@@ -512,6 +561,8 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
       console.log(chalk.red(`  ✗ Failed to configure pre-commit hook: ${e.message}`));
     }
 
+    persistRecorder(projectPath, recorder);
+
     // 5. Wire git so the hook ACTUALLY runs — this is the fix. Setting
     // `core.hooksPath` ourselves is what husky's own bootstrap does internally
     // (verified against husky ^9.1.7's source: `git config core.hooksPath
@@ -567,7 +618,7 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
 
       if (existsSync(hookPath)) {
         const existingContent = readFileSync(hookPath, 'utf-8');
-        if (existingContent.includes('uds check')) {
+        if (hookRunsUdsCheck(existingContent)) {
           console.log(chalk.gray('  ✓ Pre-commit hook already configured'));
         } else {
           // Never clobber an adopter's own hook (this fix — it used to be
@@ -576,27 +627,42 @@ export async function setupHuskyHook(projectPath, { allowInTest = false } = {})
           console.log(chalk.gray('    UDS will not overwrite it. Add "uds check" to it yourself, or remove it and re-run `uds init`.'));
         }
       } else {
+        // Fail-closed (XSPEC-444 R1 class sweep). This script used to run the linters
+        // as `... 2>/dev/null || true` and `uds check 2>/dev/null || true`, then print
+        // "Pre-commit checks passed" — it could not block a commit for any reason.
+        // Now: a linter that is installed and fails blocks the commit; one that is not
+        // installed is skipped. The UDS check is the same block the husky path writes
+        // (buildPreCommitBlock): its exit status stops the commit, and a missing CLI
+        // says so and blocks rather than being skipped in silence.
         const hookContent = `#!/bin/sh
 # UDS pre-commit hook
 # Auto-generated by uds init
 
 echo "Running UDS pre-commit checks..."
 
-# Run lint if available
+# Lint, when the language's linter is installed. A failing linter blocks the commit.
 if [ -f pyproject.toml ] || [ -f requirements.txt ]; then
-  python -m ruff check . 2>/dev/null || true
+  if python -m ruff --version >/dev/null 2>&1; then
+    python -m ruff check . || exit $?
+  fi
 elif [ -f go.mod ]; then
-  go vet ./... 2>/dev/null || true
+  if command -v go >/dev/null 2>&1; then
+    go vet ./... || exit $?
+  fi
 elif [ -f Cargo.toml ]; then
-  cargo clippy 2>/dev/null || true
+  if command -v cargo >/dev/null 2>&1; then
+    cargo clippy || exit $?
+  fi
 fi
 
-# UDS Standard Check
-uds check 2>/dev/null || true
-
+${buildPreCommitBlock({ hookFile: '.git/hooks/pre-commit' })}
 echo "Pre-commit checks passed"
 `;
         writeFileSync(hookPath, hookContent, { mode: 0o755 });
+        // Created from nothing (the branch above is "file does not exist"), so the
+        // whole file is UDS's — record its hash for `uds uninstall`.
+        recordFile(recorder, projectPath, '.git/hooks/pre-commit', RECORD_KINDS.GIT_HOOK);
+        persistRecorder(projectPath, recorder);
         console.log(chalk.green('  ✓ Installed .git/hooks/pre-commit (native git hook)'));
       }
     } catch (e) {
@@ -614,9 +680,16 @@ function buildNonInteractiveConfig(options, detected, projectPath) {
   //   CLI --locale > .uds/install.yaml locale: > UDS_LOCALE env > LANG > 'en'
   // detectLanguage() handles UDS_LOCALE + LANG fallback internally (P1-CLI-3).
   const installYaml = readInstallYaml(projectPath);
-  const displayLanguage = options.locale
+  const requestedLanguage = options.locale
     || installYaml.locale
     || detectLanguage(null);
+  // Case-insensitive, and an unsupported value is said out loud instead of silently becoming English
+  // (dev-platform XSPEC-451 follow-up: `--locale zh-CN` used to install English with exit 0).
+  const { displayLanguage: normalizedLanguage, supported } = normalizeRequestedLocale(requestedLanguage);
+  const displayLanguage = supported ? normalizedLanguage : 'en';
+  if (!supported) {
+    console.log(chalk.yellow(`⚠ Unsupported locale "${requestedLanguage}" — installing in English. Supported: ${Object.keys(LOCALE_MAP_FOR_INIT).join(', ')}.`));
+  }
   
   // Determine AI tools
   const detectedAiTools = Object.keys(detected.aiTools).filter(k => detected.aiTools[k]);

package/src/commands/uninstall.js

@@ -3,7 +3,8 @@ import { select, checkbox, confirm } from '@inquirer/prompts';
 import { readManifest, manifestExists, writeManifest } from '../core/manifest.js';
 import { t } from '../i18n/messages.js';
 import { uninstallStandards } from '../uninstallers/standards-uninstaller.js';
-import { uninstallHook } from '../uninstallers/hook-uninstaller.js';
+import { uninstallHook, pruneCreatedDirs } from '../uninstallers/hook-uninstaller.js';
+import { forgetRecords } from '../core/install-records.js';
 import { uninstallIntegrations } from '../uninstallers/integration-uninstaller.js';
 import { uninstallSkills } from '../uninstallers/skills-uninstaller.js';
 
@@ -12,6 +13,35 @@ import { uninstallSkills } from '../uninstallers/skills-uninstaller.js';
  */
 const CATEGORIES = ['hooks', 'skills', 'integrations', 'standards'];
 
+/**
+ * Exit codes. Before these existed every path out of `uninstall` was 0 — a run
+ * that removed nothing because the prompt died looked exactly like a completed
+ * uninstall to CI and to the adopter's own scripts.
+ */
+const EXIT_NOT_INITIALIZED = 1;   // nothing to uninstall / manifest unreadable
+const EXIT_CANNOT_PROMPT = 2;     // needed an answer, nobody could give one (same as `uds update`)
+const EXIT_INTERRUPTED = 130;     // the prompt was closed before answering (SIGINT convention)
+
+/**
+ * Can anything answer a prompt? Decided BEFORE a prompt is drawn.
+ *
+ * `uds update` catches ExitPromptError instead (see confirmOrFail there) and
+ * explains why it avoids `isTTY`: a wrapped stdin can answer with isTTY unset.
+ * That reasoning is sound for a prompt that has already been drawn, but it leaves
+ * the visible symptom this command was reported for — the checkbox painted onto a
+ * pipe, then a stack trace. Here the question is asked first, and only stdin
+ * matters: prompts read from it. An answer that arrives anyway (a test double, a
+ * wrapper) is not blocked by ExitPromptError handling further down.
+ */
+function canPrompt() {
+  return Boolean(process.stdin.isTTY);
+}
+
+/** `@inquirer/prompts` throws this when stdin closes or the user presses Ctrl+C. */
+function isPromptClosed(err) {
+  return err?.name === 'ExitPromptError' || /force closed the prompt/i.test(err?.message || '');
+}
+
 /**
  * Uninstall command - remove UDS standards, integrations, skills, and hooks
  * @param {Object} options - Command options
@@ -25,19 +55,25 @@ export async function uninstallCommand(options) {
   console.log(chalk.bold(msg.title));
   console.log(chalk.gray('─'.repeat(50)));
 
-  // Check if UDS is initialized
+  // Check if UDS is initialized. A project with nothing to uninstall is not a
+  // successful uninstall: exit non-zero so a script can tell the two apart.
   if (!manifestExists(projectPath)) {
     console.log(chalk.yellow(common.notInitialized));
     console.log(chalk.gray(`  ${common.runInit}`));
+    process.exitCode = EXIT_NOT_INITIALIZED;
     return;
   }
 
   const manifest = readManifest(projectPath);
   if (!manifest) {
     console.log(chalk.red(common.couldNotReadManifest));
+    process.exitCode = EXIT_NOT_INITIALIZED;
     return;
   }
 
+  const includeUserLevel = options.all || false;
+  const dryRun = options.dryRun || false;
+
   // Determine which categories to uninstall
   let selectedCategories;
   if (options.all) {
@@ -48,20 +84,34 @@ export async function uninstallCommand(options) {
     selectedCategories = ['skills'];
   } else if (options.integrationsOnly) {
     selectedCategories = ['integrations'];
-  } else if (options.yes) {
-    // --yes without specific flag → all categories
+  } else if (options.yes || dryRun) {
+    // --yes without a specific flag → all categories.
+    // --dry-run → all categories too, and WITHOUT a prompt: a dry run writes
+    // nothing, so there is nothing to ask before showing what a run would do —
+    // and its whole use is to be runnable unattended (CI, a pipe). It used to
+    // draw the category checkbox even then, and die on it.
     selectedCategories = [...CATEGORIES];
   } else {
     // Interactive: checkbox selection
-    const categories = await checkbox({
-      message: msg.selectCategories,
-      choices: [
-        { name: `${msg.categoryHooks} (.husky/pre-commit, .claude/settings.json, .codex/hooks.json, .gemini/settings.json, .agents/hooks.json)`, value: 'hooks', checked: true },
-        { name: `${msg.categorySkills} (skills, commands)`, value: 'skills', checked: true },
-        { name: `${msg.categoryIntegrations} (CLAUDE.md, .cursorrules, ...)`, value: 'integrations', checked: true },
-        { name: `${msg.categoryStandards} (.standards/)`, value: 'standards', checked: true }
-      ]
-    });
+    if (!canPrompt()) {
+      refuseToPrompt(msg);
+      return;
+    }
+    let categories;
+    try {
+      categories = await checkbox({
+        message: msg.selectCategories,
+        choices: [
+          { name: `${msg.categoryHooks} (.husky/pre-commit, .claude/settings.json, .codex/hooks.json, .gemini/settings.json, .agents/hooks.json)`, value: 'hooks', checked: true },
+          { name: `${msg.categorySkills} (skills, commands)`, value: 'skills', checked: true },
+          { name: `${msg.categoryIntegrations} (CLAUDE.md, .cursorrules, ...)`, value: 'integrations', checked: true },
+          { name: `${msg.categoryStandards} (.standards/)`, value: 'standards', checked: true }
+        ]
+      });
+    } catch (err) {
+      if (reportClosedPrompt(err, msg)) return;
+      throw err;
+    }
 
     if (categories.length === 0) {
       console.log(chalk.yellow(msg.nothingSelected));
@@ -70,9 +120,6 @@ export async function uninstallCommand(options) {
     selectedCategories = categories;
   }
 
-  const includeUserLevel = options.all || false;
-  const dryRun = options.dryRun || false;
-
   // Gather preview: run all uninstallers in dry-run mode to build summary
   const preview = await gatherPreview(projectPath, manifest, selectedCategories, includeUserLevel);
 
@@ -87,10 +134,22 @@ export async function uninstallCommand(options) {
 
   // Confirm (unless --yes or --dry-run)
   if (!dryRun && !options.yes) {
-    const confirmed = await confirm({
-      message: msg.confirmUninstall,
-      default: false
-    });
+    // Not auto-confirmed when nobody can answer: an unattended shell must not get
+    // more permission to delete files than an interactive one is given.
+    if (!canPrompt()) {
+      refuseToPrompt(msg);
+      return;
+    }
+    let confirmed;
+    try {
+      confirmed = await confirm({
+        message: msg.confirmUninstall,
+        default: false
+      });
+    } catch (err) {
+      if (reportClosedPrompt(err, msg)) return;
+      throw err;
+    }
 
     if (!confirmed) {
       console.log(chalk.yellow(common.cancelled));
@@ -106,18 +165,52 @@ export async function uninstallCommand(options) {
 
   // Execute uninstallation in order: hooks → skills → integrations → standards
   console.log();
-  const results = await executeUninstall(
-    projectPath, manifest, selectedCategories,
-    { includeUserLevel, interactive: !options.yes }
-  );
+  let results;
+  try {
+    results = await executeUninstall(
+      projectPath, manifest, selectedCategories,
+      { includeUserLevel, interactive: !options.yes }
+    );
+  } catch (err) {
+    // A per-file question asked mid-run (which is why this cannot be checked up
+    // front) was closed. Earlier steps are already done and stay done.
+    if (!isPromptClosed(err)) throw err;
+    console.log();
+    console.log(chalk.red(msg.promptClosedMidRun));
+    console.log();
+    process.exitCode = EXIT_INTERRUPTED;
+    return;
+  }
 
   // Update or remove manifest
-  updateManifestAfterUninstall(projectPath, manifest, selectedCategories);
+  updateManifestAfterUninstall(projectPath, manifest, selectedCategories, collectDeletedPaths(results));
 
   // Display results
   displayResults(results, msg);
 }
 
+/** Say why a real run cannot proceed without --yes, and set the exit code. Nothing has been changed. */
+function refuseToPrompt(msg) {
+  console.log();
+  console.log(chalk.red(msg.cannotPrompt));
+  console.log(chalk.gray(`  ${msg.cannotPromptHint}`));
+  console.log();
+  process.exitCode = EXIT_CANNOT_PROMPT;
+}
+
+/**
+ * If `err` is "the prompt was closed before an answer", report it, set a non-zero
+ * exit code and return true. Any other error is the caller's to rethrow.
+ */
+function reportClosedPrompt(err, msg) {
+  if (!isPromptClosed(err)) return false;
+  console.log();
+  console.log(chalk.red(msg.promptClosed));
+  console.log();
+  process.exitCode = EXIT_INTERRUPTED;
+  return true;
+}
+
 /**
  * Gather preview of what will be removed (dry-run all uninstallers)
  */
@@ -125,7 +218,7 @@ async function gatherPreview(projectPath, manifest, categories, includeUserLevel
   const preview = {};
 
   if (categories.includes('hooks')) {
-    preview.hooks = uninstallHook(projectPath, { dryRun: true });
+    preview.hooks = uninstallHook(projectPath, { dryRun: true, manifest });
   }
   if (categories.includes('skills')) {
     preview.skills = uninstallSkills(projectPath, manifest, { dryRun: true, includeUserLevel });
@@ -136,10 +229,23 @@ async function gatherPreview(projectPath, manifest, categories, includeUserLevel
   if (categories.includes('standards')) {
     preview.standards = uninstallStandards(projectPath, { dryRun: true });
   }
+  if (categories.includes('hooks')) {
+    // Nothing is deleted yet in a preview, so folders are judged against what the
+    // steps above WOULD delete.
+    preview.folders = pruneCreatedDirs(projectPath, manifest, {
+      dryRun: true,
+      plannedDeletions: collectDeletedPaths(preview)
+    });
+  }
 
   return preview;
 }
 
+/** Every relative path the given step results deleted (or, for a preview, would delete). */
+function collectDeletedPaths(results) {
+  return Object.values(results).flatMap((r) => r.deletedPaths || []);
+}
+
 /**
  * Execute actual uninstallation
  */
@@ -148,7 +254,7 @@ async function executeUninstall(projectPath, manifest, categories, options) {
   const results = {};
 
   if (categories.includes('hooks')) {
-    results.hooks = uninstallHook(projectPath);
+    results.hooks = uninstallHook(projectPath, { manifest });
   }
   if (categories.includes('skills')) {
     results.skills = uninstallSkills(projectPath, manifest, { includeUserLevel });
@@ -163,6 +269,10 @@ async function executeUninstall(projectPath, manifest, categories, options) {
   if (categories.includes('standards')) {
     results.standards = uninstallStandards(projectPath);
   }
+  if (categories.includes('hooks')) {
+    // After everything else, so a folder that only held UDS files is empty by now.
+    results.folders = pruneCreatedDirs(projectPath, manifest);
+  }
 
   return results;
 }
@@ -188,7 +298,7 @@ function createIntegrationPromptFn() {
 /**
  * Update or remove manifest after uninstall
  */
-function updateManifestAfterUninstall(projectPath, manifest, categories) {
+function updateManifestAfterUninstall(projectPath, manifest, categories, deletedPaths = []) {
   const removedStandards = categories.includes('standards');
 
   if (removedStandards) {
@@ -196,8 +306,10 @@ function updateManifestAfterUninstall(projectPath, manifest, categories) {
     return;
   }
 
-  // Partial uninstall: update manifest to reflect removed items
-  const updated = { ...manifest };
+  // Partial uninstall: update manifest to reflect removed items. Install records
+  // for the paths just deleted go too — a record for a file that is gone would
+  // otherwise "prove" authorship of whatever a user later puts at that path.
+  const updated = forgetRecords({ ...manifest }, deletedPaths);
 
   if (categories.includes('skills')) {
     updated.skills = {
@@ -281,6 +393,8 @@ function displayResults(results, msg) {
     console.log(chalk.green(msg.uninstallSuccess));
   } else {
     console.log(chalk.yellow(msg.uninstallPartial));
+    // "Completed with errors" is not a success to whoever runs this from a script.
+    process.exitCode = 1;
   }
   console.log(chalk.gray(`  ${msg.removed}: ${totalRemoved}  ${msg.skippedLabel}: ${totalSkipped}  ${msg.errorsLabel}: ${totalErrors}`));
 }