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

package/src/installers/integration-installer.js

@@ -141,6 +141,10 @@ export async function installIntegrations(config, projectPath) {
     if (result.success) {
       results.integrations.push(result.path);
       generatedFiles.add(targetFile);
+      // Files this run created from nothing (not merged into an existing file);
+      // init records them so uninstall can prove they are wholly UDS's. Added only
+      // when there is one, so an empty run keeps its original result shape.
+      if (result.created) (results.createdFiles ||= []).push(result.path);
 
       // Capture integration block hash for tracking UDS content
       if (result.blockHashInfo) {
@@ -310,7 +314,7 @@ export async function generateUniversalAgentsMd(config, integrationResults, proj
 
   if (result.success) {
     spinner.succeed(msg.generatedAgentsMd || 'Generated AGENTS.md (universal summary)');
-    return { path: result.path, error: null, blockHashInfo: result.blockHashInfo };
+    return { path: result.path, error: null, blockHashInfo: result.blockHashInfo, created: result.created };
   } else {
     spinner.warn(msg.couldNotGenerateAgentsMd || 'Could not generate AGENTS.md');
     return { path: null, error: result.error };

package/src/installers/standards-installer.js

@@ -7,7 +7,7 @@ import {
   getOptionSource,
   findOption
 } from '../utils/registry.js';
-import { copyStandard } from '../utils/copier.js';
+import { copyStandard, copyExtension } from '../utils/copier.js';
 import { t } from '../i18n/messages.js';
 import { computeFileHash } from '../utils/hasher.js';
 import { MANIFEST_OPTION_BINDINGS } from '../core/constants.js';
@@ -115,36 +115,29 @@ export async function installStandards(config, projectPath) {
   if (config.languages.length > 0 || config.frameworks.length > 0 || localeExtension) {
     const extSpinner = createSpinner(msg.copyingExtensions).start();
 
-    for (const lang of config.languages) {
-      if (EXTENSION_MAPPINGS[lang]) {
-        const result = await copyStandard(EXTENSION_MAPPINGS[lang], '.standards', projectPath);
-        if (result.success) {
-          results.extensions.push(EXTENSION_MAPPINGS[lang]);
-        } else {
-          results.errors.push(`${EXTENSION_MAPPINGS[lang]}: ${result.error}`);
-        }
+    // One helper, one copy call. Extension files come from the installed package only:
+    // a declared extension that is missing from it is an error naming that file, never a
+    // download and never a silent skip (XSPEC-452 R2).
+    const installExtension = async (sourcePath) => {
+      const result = await copyExtension(sourcePath, '.standards', projectPath);
+      if (result.success) {
+        results.extensions.push(sourcePath);
+      } else {
+        results.errors.push(`${sourcePath}: ${result.error}`);
       }
+    };
+
+    for (const lang of config.languages) {
+      if (EXTENSION_MAPPINGS[lang]) await installExtension(EXTENSION_MAPPINGS[lang]);
     }
 
     for (const fw of config.frameworks) {
-      if (EXTENSION_MAPPINGS[fw]) {
-        const result = await copyStandard(EXTENSION_MAPPINGS[fw], '.standards', projectPath);
-        if (result.success) {
-          results.extensions.push(EXTENSION_MAPPINGS[fw]);
-        } else {
-          results.errors.push(`${EXTENSION_MAPPINGS[fw]}: ${result.error}`);
-        }
-      }
+      if (EXTENSION_MAPPINGS[fw]) await installExtension(EXTENSION_MAPPINGS[fw]);
     }
 
     // Auto-install locale extension based on display language
     if (localeExtension && EXTENSION_MAPPINGS[localeExtension]) {
-      const result = await copyStandard(EXTENSION_MAPPINGS[localeExtension], '.standards', projectPath);
-      if (result.success) {
-        results.extensions.push(EXTENSION_MAPPINGS[localeExtension]);
-      } else {
-        results.errors.push(`${EXTENSION_MAPPINGS[localeExtension]}: ${result.error}`);
-      }
+      await installExtension(EXTENSION_MAPPINGS[localeExtension]);
     }
 
     extSpinner.succeed(msg.copiedExtensions.replace('{count}', results.extensions.length));

package/src/reconciler/plan-executor.js

@@ -249,18 +249,17 @@ async function executeCreateOrUpdate(projectPath, action, manifest) {
       let targetDir = '.standards';
 
       if (metadata?.extensionSource) {
-        // An entry from `manifest.extensions`. PathResolver cannot resolve these
-        // from an npm install: the published package's `files` list is bin, src,
-        // bundled, standards-registry.json and README.md — no `extensions/`. So
-        // `sourcePath` is null for every adopter who did not install from a
-        // source checkout, and this function answered "No source path available"
-        // for a file it was perfectly able to fetch.
+        // An entry from `manifest.extensions`. It is resolved from the installed
+        // package (`bundled/extensions/`, shipped since XSPEC-452) — never from GitHub.
+        // `copyStandard` hands any `extensions/` path to `copyExtension`, which fails
+        // by name when the package lacks the file, instead of downloading it.
         //
-        // The legacy update path never had the bug because it calls copyStandard
-        // directly (`update.js`, "Update extensions"). The same upgrade therefore
-        // refreshed `.standards/zh-tw.md` under `uds update` and failed under the
-        // reconciler — the two paths disagreed about whether the file was
-        // reachable, and only one of them was right. (XSPEC-343)
+        // History: before XSPEC-452 the published package had no `extensions/`, so
+        // `sourcePath` was null for every adopter who did not install from a source
+        // checkout, and this function answered "No source path available" for a file it
+        // could fetch from GitHub. The legacy update path (`update.js`, "Update
+        // extensions") was the one that worked — only because it fell back to a
+        // download. (XSPEC-343)
         sourceStr = metadata.extensionSource;
       } else if (metadata?.registryEntry) {
         const source = metadata.registryEntry.source;

package/src/uninstallers/hook-uninstaller.js

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'fs';
 import { join, basename } from 'path';
+import { proveUnchanged, RECORD_KINDS, RECORDS_KEY, isRealDirectory } from '../core/install-records.js';
+import { stripUdsHookBlock } from '../utils/git-hooks.js';
 import {
   collectHookConfigs, standardsSourceDir, hooksSourceDir,
   CODEX_HOOK_SCRIPT, GEMINI_HOOK_SCRIPT, AGY_HOOK_SCRIPT,
@@ -88,7 +90,7 @@ function applyHooksMap(config, nextMap) {
  * difference is which file and which key they look at.
  */
 function uninstallHookConfigFile({ configPath, label, dryRun, deleteEmptyFile }) {
-  const result = { removed: [], skipped: [], errors: [] };
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
   if (!existsSync(configPath)) return result; // nothing installed here — nothing to report
 
   let config;
@@ -106,18 +108,21 @@ function uninstallHookConfigFile({ configPath, label, dryRun, deleteEmptyFile })
   }
 
   const entryLabel = `${label} (${removedCount} UDS hook ${removedCount === 1 ? 'entry' : 'entries'})`;
+  const updatedConfig = applyHooksMap(config, nextMap);
+  const willDeleteFile = deleteEmptyFile && Object.keys(updatedConfig).length === 0;
+  // Decided BEFORE the dry-run return: the preview must say the file goes away,
+  // and the folder-cleanup step needs to know the folder will be empty.
   if (dryRun) {
-    result.removed.push(entryLabel);
+    result.removed.push(willDeleteFile ? `${entryLabel}, file removed — created by UDS, now empty` : entryLabel);
+    if (willDeleteFile) result.deletedPaths.push(label);
     return result;
   }
 
-  const updatedConfig = applyHooksMap(config, nextMap);
-  const isNowEmpty = Object.keys(updatedConfig).length === 0;
-
   try {
-    if (deleteEmptyFile && isNowEmpty) {
+    if (willDeleteFile) {
       unlinkSync(configPath);
       result.removed.push(`${entryLabel}, file removed — created by UDS, now empty`);
+      result.deletedPaths.push(label);
     } else {
       writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + '\n');
       result.removed.push(entryLabel);
@@ -186,7 +191,7 @@ export function uninstallAgyHooks(projectPath, options = {}) {
   const configPath = join(projectPath, '.agents', 'hooks.json');
   const label = '.agents/hooks.json';
   const dryRun = options.dryRun || false;
-  const result = { removed: [], skipped: [], errors: [] };
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
   if (!existsSync(configPath)) return result;
 
   let config;
@@ -242,14 +247,17 @@ export function uninstallAgyHooks(projectPath, options = {}) {
   }
 
   const entryLabel = `${label} (${removedCount} UDS hook ${removedCount === 1 ? 'entry' : 'entries'})`;
+  const willDeleteFile = Object.keys(next).length === 0;
   if (dryRun) {
-    result.removed.push(entryLabel);
+    result.removed.push(willDeleteFile ? `${entryLabel}, file removed — created by UDS, now empty` : entryLabel);
+    if (willDeleteFile) result.deletedPaths.push(label);
     return result;
   }
   try {
-    if (Object.keys(next).length === 0) {
+    if (willDeleteFile) {
       unlinkSync(configPath);
       result.removed.push(`${entryLabel}, file removed — created by UDS, now empty`);
+      result.deletedPaths.push(label);
     } else {
       writeFileSync(configPath, JSON.stringify(next, null, 2) + '\n');
       result.removed.push(entryLabel);
@@ -260,18 +268,113 @@ export function uninstallAgyHooks(projectPath, options = {}) {
   return result;
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Proof of authorship — "only delete what UDS can prove it wrote, unchanged".
+//
+// A record in `manifest.installedArtifacts` (core/install-records.js) says UDS
+// wrote a file; a matching hash says nobody has changed it since. Both are
+// required to delete a whole file. Anything else is KEPT, and the reason is
+// printed, because "not provably ours" is the honest state of a file from an
+// older UDS (no record) or one an adopter has edited (hash differs) — and
+// guessing "probably ours" is how an adopter's own hook script gets deleted.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Relative paths (forward slashes) of every file under `dir`, or [] if it is not there. */
+function listFiles(dir, rel = '') {
+  if (!dir || !existsSync(dir)) return [];
+  const out = [];
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) out.push(...listFiles(join(dir, e.name), r));
+    else out.push(r);
+  }
+  return out;
+}
+
+/**
+ * Remove the hook scripts UDS copied into `scripts/hooks/`.
+ *
+ * `scripts/hooks/` is a directory UDS scaffolds inside the adopter's project, so
+ * an adopter's own scripts can sit beside ours (a test in hook-uninstaller.test.js
+ * places one there and it must survive). Only files that have an install record
+ * AND still match it are deleted.
+ */
+export function uninstallHookScripts(projectPath, manifest, { dryRun = false, blockedBy = null } = {}) {
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
+  const files = manifest?.[RECORDS_KEY]?.files || {};
+  const recorded = Object.entries(files)
+    .filter(([, rec]) => rec && rec.kind === RECORD_KINDS.HOOK_SCRIPT)
+    .map(([rel]) => rel)
+    .sort();
+
+  for (const rel of recorded) {
+    const abs = join(projectPath, rel);
+    if (!existsSync(abs)) continue; // already gone — nothing to remove, nothing to report
+    if (blockedBy) {
+      result.skipped.push(`${rel} (kept: ${blockedBy})`);
+      continue;
+    }
+    const proof = proveUnchanged(manifest, projectPath, rel);
+    if (proof.state !== 'proven') {
+      result.skipped.push(`${rel} (kept: ${proof.why})`);
+      continue;
+    }
+    try {
+      if (!dryRun) unlinkSync(abs);
+      result.removed.push(`${rel} (deleted — installed by UDS, ${proof.why})`);
+      result.deletedPaths.push(rel);
+    } catch (error) {
+      result.errors.push(`${rel} — ${error.message}`);
+    }
+  }
+
+  // Files that carry the name of a script UDS ships but have no record. Say so once,
+  // so a leftover `scripts/hooks/` is an explained decision and not a silent gap.
+  const recordedSet = new Set(recorded);
+  const shipped = listFiles(hooksSourceDir());
+  const unrecorded = shipped
+    .map((f) => `scripts/hooks/${f}`)
+    .filter((rel) => existsSync(join(projectPath, rel)) && !recordedSet.has(rel));
+  if (unrecorded.length > 0) {
+    result.skipped.push(
+      `scripts/hooks/ (kept: ${unrecorded.length} file${unrecorded.length === 1 ? '' : 's'} carry the name of a UDS hook script, ` +
+      'but the manifest has no record that UDS wrote them — installed by an older UDS, or by hand. ' +
+      'Delete them yourself if you no longer want them)'
+    );
+  }
+  return result;
+}
+
+// Line-level fallback, for the one-line form older UDS wrote and for a block whose
+// end marker an adopter removed. The current block is removed whole, by its markers
+// (stripUdsHookBlock) — its inner lines are not individually matchable.
+const UDS_PRECOMMIT_LINE = /uds\s+check|universal-dev-standards\s+check|checkin-standards|^#\s*UDS Standard Check\s*$/;
+const NATIVE_UDS_LINE = /uds\s+check|checkin-standards|UDS pre-commit hook/;
+
+/** True when nothing is left but a shebang and blank lines. */
+function nothingButShebang(lines) {
+  return lines.every((l) => !l.trim() || /^#!/.test(l.trim()));
+}
+
 /**
  * Remove UDS-related lines from .husky/pre-commit, the native
  * .git/hooks/pre-commit fallback, and the enforcement-hook entries UDS wrote
  * into .claude/settings.json, .codex/hooks.json, .gemini/settings.json and
- * .agents/hooks.json.
+ * .agents/hooks.json; and the hook scripts copied into scripts/hooks/.
+ *
+ * Whole-file deletion (a hook file, a script) needs proof — see proveUnchanged.
+ * A hook file that is not provably wholly UDS's still has its UDS lines removed
+ * (each is a line UDS wrote, and the rest of the file is untouched) and the
+ * remainder is reported as kept, with the reason.
+ *
  * @param {string} projectPath - Project root path
- * @param {Object} options - { dryRun: boolean }
- * @returns {Object} { removed: string[], skipped: string[], errors: string[] }
+ * @param {Object} options - { dryRun: boolean, manifest: object|null }
+ *   `manifest` must be read BEFORE `.standards/` is removed; it carries the install records.
+ * @returns {Object} { removed: string[], skipped: string[], errors: string[], deletedPaths: string[] }
  */
 export function uninstallHook(projectPath, options = {}) {
-  const { dryRun = false } = options;
-  const result = { removed: [], skipped: [], errors: [] };
+  const { dryRun = false, manifest = null } = options;
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
   const hookPath = join(projectPath, '.husky', 'pre-commit');
 
   if (!existsSync(hookPath)) {
@@ -279,12 +382,23 @@ export function uninstallHook(projectPath, options = {}) {
   } else {
     try {
       const content = readFileSync(hookPath, 'utf-8');
+      const proof = proveUnchanged(manifest, projectPath, '.husky/pre-commit');
       const lines = content.split('\n');
-      const udsPattern = /uds\s+check|checkin-standards/;
-      const filteredLines = lines.filter(line => !udsPattern.test(line));
+      const filteredLines = stripUdsHookBlock(content).content.split('\n')
+        .filter(line => !UDS_PRECOMMIT_LINE.test(line));
 
-      if (filteredLines.length === lines.length) {
+      if (proof.state === 'proven') {
+        // UDS created this file and nobody has touched it: nothing of the adopter's is in it.
+        if (!dryRun) unlinkSync(hookPath);
+        result.removed.push(`.husky/pre-commit (deleted — created by UDS, ${proof.why})`);
+        result.deletedPaths.push('.husky/pre-commit');
+      } else if (filteredLines.length === lines.length) {
         result.skipped.push('.husky/pre-commit (no UDS lines found)');
+      } else if (nothingButShebang(filteredLines)) {
+        // Only UDS's lines (and a shebang) were in it — removing them leaves nothing worth keeping.
+        if (!dryRun) unlinkSync(hookPath);
+        result.removed.push('.husky/pre-commit (UDS check lines; file removed — nothing else was in it)');
+        result.deletedPaths.push('.husky/pre-commit');
       } else if (dryRun) {
         result.removed.push('.husky/pre-commit (UDS check lines)');
       } else {
@@ -301,25 +415,32 @@ export function uninstallHook(projectPath, options = {}) {
   if (existsSync(nativeHookPath)) {
     try {
       const content = readFileSync(nativeHookPath, 'utf-8');
-      const udsPattern = /uds\s+check|checkin-standards|UDS pre-commit hook/;
+      const proof = proveUnchanged(manifest, projectPath, '.git/hooks/pre-commit');
 
-      if (!udsPattern.test(content)) {
+      if (proof.state === 'proven') {
+        // The whole script is what `uds init` wrote — including the parts no line
+        // pattern would ever match (its "Auto-generated by uds init" header, the
+        // linter fallbacks, the closing echo). Deleting only the matching lines
+        // used to leave that body behind, still executable, still claiming
+        // "Pre-commit checks passed".
+        if (!dryRun) unlinkSync(nativeHookPath);
+        result.removed.push(`.git/hooks/pre-commit (UDS native hook, file removed — ${proof.why})`);
+        result.deletedPaths.push('.git/hooks/pre-commit');
+      } else if (!NATIVE_UDS_LINE.test(content) && !stripUdsHookBlock(content).removed) {
         result.skipped.push('.git/hooks/pre-commit (no UDS lines found)');
-      } else if (dryRun) {
-        result.removed.push('.git/hooks/pre-commit (UDS native hook)');
       } else {
-        // Remove only UDS-related lines, keep other hook content
-        const lines = content.split('\n');
-        const filtered = lines.filter(line => !udsPattern.test(line));
-
-        // If only shebang remains, remove the file entirely; otherwise rewrite
-        const nonEmpty = filtered.filter(l => l.trim() && l.trim() !== '#!/bin/sh');
-        if (nonEmpty.length === 0) {
-          unlinkSync(nativeHookPath);
+        // The block the native hook carries is removed whole, by its markers — its
+        // inner lines are not individually matchable (same as the husky path above).
+        const filtered = stripUdsHookBlock(content).content.split('\n')
+          .filter(line => !NATIVE_UDS_LINE.test(line));
+        if (nothingButShebang(filtered)) {
+          if (!dryRun) unlinkSync(nativeHookPath);
           result.removed.push('.git/hooks/pre-commit (UDS native hook, file removed)');
+          result.deletedPaths.push('.git/hooks/pre-commit');
         } else {
-          writeFileSync(nativeHookPath, filtered.join('\n'), 'utf-8');
+          if (!dryRun) writeFileSync(nativeHookPath, filtered.join('\n'), 'utf-8');
           result.removed.push('.git/hooks/pre-commit (UDS lines removed)');
+          result.skipped.push(`.git/hooks/pre-commit (kept: the rest of the script — ${proof.why})`);
         }
       }
     } catch (error) {
@@ -329,16 +450,81 @@ export function uninstallHook(projectPath, options = {}) {
 
   // Enforcement hooks written by installHooks()/installCodexHooks()/installGeminiHooks()
   // — the gap this function used to have entirely (see module doc comment above).
-  for (const sub of [
+  const configResults = [
     uninstallClaudeCodeHooks(projectPath, { dryRun }),
     uninstallCodexHooks(projectPath, { dryRun }),
     uninstallGeminiHooks(projectPath, { dryRun }),
     uninstallAgyHooks(projectPath, { dryRun }),
-  ]) {
+  ];
+  for (const sub of configResults) {
     result.removed.push(...sub.removed);
     result.skipped.push(...sub.skipped);
     result.errors.push(...sub.errors);
+    result.deletedPaths.push(...sub.deletedPaths);
   }
 
+  // The scripts those entries ran. If a config file could not be cleaned (it still
+  // names a script), deleting the script would turn a working hook into a failing one.
+  const configFailed = configResults.some((r) => r.errors.length > 0);
+  const scripts = uninstallHookScripts(projectPath, manifest, {
+    dryRun,
+    blockedBy: configFailed ? 'a hook config file could not be cleaned (see the error above) and still runs this script' : null
+  });
+  result.removed.push(...scripts.removed);
+  result.skipped.push(...scripts.skipped);
+  result.errors.push(...scripts.errors);
+  result.deletedPaths.push(...scripts.deletedPaths);
+
+  return result;
+}
+
+/**
+ * Remove the folders UDS had to create for its files (`.codex/`, `scripts/hooks/`, ...),
+ * once they are empty.
+ *
+ * A folder is removed only if (a) the manifest recorded that UDS created it and
+ * (b) nothing is left in it. An empty `.codex/` that the adopter made themselves is
+ * indistinguishable by looking; the record is the only thing that tells them apart.
+ * A folder that still holds anything — `.agents/rules/style.md` — is kept and
+ * reported, so the adopter sees why it stayed.
+ *
+ * In a dry run nothing has been deleted yet, so `plannedDeletions` (relative paths
+ * the run WOULD delete) stands in for the missing deletions when judging "empty".
+ *
+ * @param {string} projectPath
+ * @param {Object|null} manifest - read before `.standards/` was removed
+ * @param {{ dryRun?: boolean, plannedDeletions?: string[] }} [options]
+ * @returns {{ removed: string[], skipped: string[], errors: string[], deletedPaths: string[] }}
+ */
+export function pruneCreatedDirs(projectPath, manifest, { dryRun = false, plannedDeletions = [] } = {}) {
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
+  const dirs = manifest?.[RECORDS_KEY]?.createdDirs || [];
+  const gone = new Set(plannedDeletions.map((p) => p.replace(/\\/g, '/')));
+  // Deepest first: `scripts/hooks` must go before `scripts` can be seen as empty.
+  const ordered = [...new Set(dirs)]
+    .filter((d) => d && !d.startsWith('..') && !d.startsWith('/'))
+    .sort((a, b) => b.split('/').length - a.split('/').length);
+
+  for (const rel of ordered) {
+    const abs = join(projectPath, rel);
+    if (!existsSync(abs)) continue;
+    if (!isRealDirectory(abs)) {
+      result.skipped.push(`${rel}/ (kept: not a plain directory)`);
+      continue;
+    }
+    try {
+      const left = readdirSync(abs).filter((name) => !gone.has(`${rel}/${name}`));
+      if (left.length > 0) {
+        result.skipped.push(`${rel}/ (kept: created by UDS but not empty — still holds ${left.slice(0, 3).join(', ')}${left.length > 3 ? ', ...' : ''}, which UDS did not write)`);
+        continue;
+      }
+      if (!dryRun) rmdirSync(abs);
+      gone.add(rel);
+      result.removed.push(`${rel}/ (empty folder created by UDS, removed)`);
+      result.deletedPaths.push(rel);
+    } catch (error) {
+      result.errors.push(`${rel}/ — ${error.message}`);
+    }
+  }
   return result;
 }

package/src/uninstallers/integration-uninstaller.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { extractMarkedContent } from '../utils/integration-generator.js';
 import { SUPPORTED_AI_TOOLS } from '../core/constants.js';
 import { resolveIntegrationFile } from '../core/constants.js';
+import { proveUnchanged } from '../core/install-records.js';
 
 /**
  * Get the format for a given integration file name
@@ -29,7 +30,7 @@ function getFormatForFile(fileName) {
  */
 export async function uninstallIntegrations(projectPath, manifest, options = {}) {
   const { dryRun = false, interactive = false, promptFn = null } = options;
-  const result = { removed: [], skipped: [], errors: [] };
+  const result = { removed: [], skipped: [], errors: [], deletedPaths: [] };
 
   const integrations = manifest?.integrations || [];
   if (integrations.length === 0) {
@@ -64,11 +65,27 @@ export async function uninstallIntegrations(projectPath, manifest, options = {})
       const userContent = (parts.before.trim() + parts.after.trim()).trim();
       const hasUserContent = userContent.length > 0;
 
+      // Text outside the UDS block is not automatically the adopter's. A file UDS
+      // creates from nothing carries generated text there — AGENTS.md's
+      // "> Auto-generated by ..." header and sections, CLAUDE.md's leading guidance —
+      // and treating all of it as "user content" left an orphaned file pointing at
+      // the `.standards/` this very command removes. It is only "not the adopter's"
+      // if UDS recorded a hash of it when it created the file and the text still
+      // matches; without that proof it stays, and the reason is printed.
+      const proof = hasUserContent ? proveUnchanged(manifest, projectPath, fileName) : null;
+      const outsideIsUdsOwn = hasUserContent && proof.state === 'proven';
+      const keptNote = () => `${fileName} (kept: the text outside the UDS block — ${proof.why})`;
+
       if (dryRun) {
-        if (hasUserContent) {
-          result.removed.push(`${fileName} (remove UDS block, keep user content)`);
-        } else {
+        if (!hasUserContent) {
           result.removed.push(`${fileName} (delete file)`);
+          result.deletedPaths.push(fileName);
+        } else if (outsideIsUdsOwn) {
+          result.removed.push(`${fileName} (delete file — everything outside the UDS block was generated by UDS)`);
+          result.deletedPaths.push(fileName);
+        } else {
+          result.removed.push(`${fileName} (remove UDS block, keep user content)`);
+          result.skipped.push(keptNote());
         }
         continue;
       }
@@ -77,26 +94,39 @@ export async function uninstallIntegrations(projectPath, manifest, options = {})
         // 100% UDS-generated → delete entire file
         unlinkSync(filePath);
         result.removed.push(`${fileName} (deleted)`);
+        result.deletedPaths.push(fileName);
+      } else if (outsideIsUdsOwn) {
+        // UDS created this file and its non-block text is still exactly what UDS
+        // wrote: there is no adopter content to preserve, so no question to ask.
+        unlinkSync(filePath);
+        result.removed.push(`${fileName} (deleted — everything outside the UDS block was generated by UDS and is unchanged)`);
+        result.deletedPaths.push(fileName);
       } else if (interactive && promptFn) {
         // Ask user what to do
         const action = await promptFn(fileName, hasUserContent);
         if (action === 'delete-file') {
           unlinkSync(filePath);
           result.removed.push(`${fileName} (deleted)`);
+          result.deletedPaths.push(fileName);
         } else if (action === 'remove-block') {
           const cleaned = (parts.before + parts.after).trim() + '\n';
           writeFileSync(filePath, cleaned, 'utf-8');
           result.removed.push(`${fileName} (UDS block removed)`);
+          result.skipped.push(keptNote());
         } else {
           result.skipped.push(`${fileName} (user skipped)`);
         }
       } else {
-        // Non-interactive (--yes): remove UDS block only, preserve user content
+        // Non-interactive (--yes): remove UDS block only, preserve everything else
         const cleaned = (parts.before + parts.after).trim() + '\n';
         writeFileSync(filePath, cleaned, 'utf-8');
         result.removed.push(`${fileName} (UDS block removed)`);
+        result.skipped.push(keptNote());
       }
     } catch (error) {
+      // A closed prompt is the user stopping the run, not a failure of this file:
+      // let the command report it (and exit non-zero) instead of retrying the next file.
+      if (error?.name === 'ExitPromptError') throw error;
       result.errors.push(`${fileName} — ${error.message}`);
     }
   }

package/src/utils/copier.js

@@ -26,15 +26,72 @@ function getSourcePath(sourcePath) {
   return PathResolver.getStandardSource(sourcePath);
 }
 
+/**
+ * Is this source path one of the add-on files under `extensions/`?
+ * @param {string} sourcePath - Relative path from repo root
+ * @returns {boolean}
+ */
+export function isExtensionPath(sourcePath) {
+  return typeof sourcePath === 'string' && sourcePath.replace(/\\/g, '/').startsWith('extensions/');
+}
+
+/**
+ * Copy an extension file (language style guide, framework pattern, locale pack)
+ * into the target project — from the installed package ONLY.
+ *
+ * 🔴 There is deliberately no download fallback here (XSPEC-452 R2). `extensions/`
+ * used to be missing from the npm package, so the copy below fell through to
+ * `raw.githubusercontent.com/.../main`: offline installs failed, an install pulled
+ * whatever `main` held that day instead of the version the adopter had installed,
+ * and a file that did not exist anywhere (`extensions/locales/zh-cn.md`, XSPEC-451)
+ * hid behind that fallback until someone ran the locale. A declared extension that
+ * is not in the package is a packaging defect, so it fails — by name.
+ *
+ * @param {string} sourcePath - Relative path from repo root (e.g., 'extensions/locales/zh-tw.md')
+ * @param {string} targetDir - Target directory (usually '.standards')
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Result with success status and copied path
+ */
+export async function copyExtension(sourcePath, targetDir, projectPath) {
+  try {
+    const source = getSourcePath(sourcePath);
+    if (!source) {
+      return failure(
+        `Extension file not found in the installed package: ${sourcePath} (extension files are never downloaded; reinstall or upgrade universal-dev-standards)`,
+        ERROR_CODES.FILE_NOT_FOUND,
+        { sourcePath, targetDir }
+      );
+    }
+    const targetFolder = join(projectPath, targetDir);
+    const targetFile = join(targetFolder, basename(sourcePath));
+    if (!existsSync(targetFolder)) {
+      mkdirSync(targetFolder, { recursive: true });
+    }
+    copyFileSync(source, targetFile);
+    return success(targetFile, { source: 'local', sourcePath, targetFile });
+  } catch (error) {
+    return failure(
+      error.message,
+      ERROR_CODES.FILE_COPY_FAILED,
+      { sourcePath, targetDir, projectPath }
+    );
+  }
+}
+
 /**
  * Copy a standard file to target project
  * Falls back to downloading from GitHub if local file not found
+ * (except for `extensions/` files, which are package-only — see copyExtension)
  * @param {string} sourcePath - Relative path from repo root (e.g., 'core/anti-hallucination.md')
  * @param {string} targetDir - Target directory (usually '.standards')
  * @param {string} projectPath - Project root path
  * @returns {Promise<Object>} Result with success status and copied path
  */
 export async function copyStandard(sourcePath, targetDir, projectPath) {
+  // Extensions never take the GitHub fallback below, whichever caller got here (XSPEC-452 R2).
+  if (isExtensionPath(sourcePath)) {
+    return copyExtension(sourcePath, targetDir, projectPath);
+  }
   try {
     const targetFolder = join(projectPath, targetDir);
     const targetFile = join(targetFolder, basename(sourcePath));