@haus-tech/haus-workflow 1.1.2 → 1.3.0

package/dist/cli.js

@@ -60,15 +60,15 @@ var init_exec = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import path45 from "node:path";
+import path53 from "node:path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
-import path17 from "node:path";
+import path22 from "node:path";
 import checkbox from "@inquirer/checkbox";
 
 // src/catalog/load-catalog.ts
-import path4 from "node:path";
+import path9 from "node:path";
 
 // src/utils/fs.ts
 import crypto from "node:crypto";
@@ -211,10 +211,9 @@ function packageRoot() {
   return path2.resolve(path2.dirname(file), "../..");
 }
 
-// src/catalog/remote-catalog.ts
-import os2 from "node:os";
-import path3 from "node:path";
-import fs2 from "fs-extra";
+// src/catalog/remote-catalog/github-tree.ts
+import path6 from "node:path";
+import fs4 from "fs-extra";
 
 // src/utils/logger.ts
 var log = (msg, ...args) => {
@@ -234,275 +233,287 @@ var SUPERPOWERS_SHARED_CATALOG_REL = "skills/superpowers/shared";
 var CATALOG_REF = process.env.HAUS_CATALOG_REF;
 var CATALOG_CACHE_SUBDIR = ".claude/haus/catalog-cache";
 
-// library/catalog/validation-rules.json
-var validation_rules_default = {
-  forbiddenTags: [
-    "python",
-    "django",
-    "go",
-    "rust",
-    "java",
-    "spring",
-    "kotlin",
-    "swift",
-    "android",
-    "flutter",
-    "dart",
-    "c++",
-    "perl",
-    "defi",
-    "trading"
-  ],
-  requiredSkillFrontmatter: ["description"],
-  riskyInstallPatterns: [
-    { source: "\\bnpx\\s+-y\\b", flags: "i" },
-    { source: "\\bnpx\\s+--yes\\b", flags: "i" },
-    { source: "\\byarn\\s+dlx\\b", flags: "i" },
-    { source: "\\bpnpm\\s+dlx\\b", flags: "i" }
-  ],
-  allowedNpxPattern: { source: "\\bnpx\\s+tsx\\b", flags: "i" },
-  anyNpxPattern: { source: "\\bnpx\\s+\\S+", flags: "i" },
-  npxTsxOnlyExemptSources: ["curated"],
-  httpUrlPattern: { source: "^http:\\/\\/", flags: "i" },
-  placeholderPattern: { source: "\\bTODO\\b|\\bPLACEHOLDER\\b", flags: "i" },
-  allowedStacks: [
-    "haus",
-    "security",
-    "quality",
-    "frontend",
-    "backend",
-    "testing",
-    "review",
-    "workflow",
-    "reference-pack",
-    "core-skill",
-    "workflow-skill",
-    "stack-skill",
-    "review-skill",
-    "agent",
-    "hook",
-    "rule",
-    "react",
-    "typescript",
-    "php",
-    "csharp",
-    "vendure",
-    "vendure3",
-    "nestjs",
-    "graphql",
-    "nx",
-    "turbo",
-    "nextjs",
-    "react19",
-    "typescript5",
-    "vite8",
-    "tanstack-query",
-    "tanstack-router",
-    "radix",
-    "radix-ui",
-    "shadcn",
-    "shadcn-ui",
-    "tailwind",
-    "tailwindcss",
-    "scss",
-    "scss-modules",
-    "vue",
-    "expressjs",
-    "laravel",
-    "laravel-nova",
-    "wordpress",
-    "bedrock",
-    "elementor-pro",
-    "acf-pro",
-    "jetengine",
-    "dotnet",
-    "oidc",
-    "azure-ad",
-    "bankid",
-    "crypto",
-    "postgresql",
-    "mariadb",
-    "mssql",
-    "elasticsearch",
-    "yarn4",
-    "pnpm89",
-    "playwright",
-    "testing-library",
-    "phpunit",
-    "storybook",
-    "vitest",
-    "jest",
-    "redis",
-    "sanity",
-    "strapi",
-    "prisma",
-    "cms",
-    "database",
-    "mysql",
-    "saml2",
-    "next-auth",
-    "auth",
-    "expo",
-    "react-native",
-    "mobile",
-    "i18next",
-    "i18n",
-    "bullmq",
-    "queue",
-    "sentry",
-    "observability",
-    "tooling",
-    "prettier",
-    "eslint",
-    "missing-prettier",
-    "missing-eslint",
-    "docker",
-    "pm2",
-    "stripe",
-    "qliro",
-    "supabase",
-    "payments",
-    "myid",
-    "cgi",
-    "collection2",
-    "deployer-php"
-  ],
-  alwaysAllowedTags: [
-    "haus",
-    "security",
-    "quality",
-    "review",
-    "workflow",
-    "baseline",
-    "project-instructions"
-  ],
-  patternTagSuffixes: ["-patterns"]
-};
-
-// src/catalog/validation-rules.ts
-var toRegExp = (r) => new RegExp(r.source, r.flags);
-var FORBIDDEN_TAGS = validation_rules_default.forbiddenTags;
-var REQUIRED_SKILL_FRONTMATTER = validation_rules_default.requiredSkillFrontmatter;
-var RISKY_INSTALL_PATTERNS = validation_rules_default.riskyInstallPatterns.map(toRegExp);
-var ALLOWED_NPX_PATTERN = toRegExp(validation_rules_default.allowedNpxPattern);
-var ANY_NPX_PATTERN = toRegExp(validation_rules_default.anyNpxPattern);
-var NPX_TSX_ONLY_EXEMPT_SOURCES = validation_rules_default.npxTsxOnlyExemptSources ?? [];
-function isNpxTsxOnlyExempt(_itemType, itemSource) {
-  return Boolean(itemSource && NPX_TSX_ONLY_EXEMPT_SOURCES.includes(itemSource));
+// src/catalog/path-safety.ts
+import path3 from "node:path";
+function isSafeCatalogPath(itemPath) {
+  if (!itemPath || path3.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
+  const normalized = path3.normalize(itemPath);
+  return !normalized.startsWith("..") && !normalized.includes("/..");
 }
-function buildItemPathSourceMap(items) {
-  const map = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (!item.path) continue;
-    map.set(String(item.path).replace(/\\/g, "/"), item.source);
-  }
-  return map;
+function isSafeRelativeFilePath(rel) {
+  if (!rel || rel.startsWith("/") || rel.includes("\\") || rel.includes("//")) return false;
+  if (path3.isAbsolute(rel)) return false;
+  const normalized = path3.posix.normalize(rel.replace(/\\/g, "/"));
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
 }
-function resolveMarkdownItemSource(relPath, pathSourceMap) {
-  const norm = relPath.replace(/\\/g, "/");
-  let cursor = norm;
-  while (true) {
-    if (pathSourceMap.has(cursor)) return pathSourceMap.get(cursor);
-    const slash = cursor.lastIndexOf("/");
-    if (slash === -1) break;
-    cursor = cursor.slice(0, slash);
+function safeJoin(base, itemPath) {
+  if (!isSafeCatalogPath(itemPath)) return null;
+  const resolved = path3.resolve(base, itemPath);
+  return resolved.startsWith(base + path3.sep) || resolved === base ? resolved : null;
+}
+
+// src/catalog/remote-catalog/http.ts
+import path4 from "node:path";
+import fs2 from "fs-extra";
+async function fetchGuarded(url, extract) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+    if (!res.ok) {
+      warn(`Catalog fetch HTTP ${res.status}: ${url}`);
+      return null;
+    }
+    return await extract(res);
+  } catch (e) {
+    warn(`Catalog fetch failed (${e instanceof Error ? e.constructor.name : String(e)}): ${url}`);
+    return null;
   }
-  return void 0;
 }
-var HTTP_URL_PATTERN = toRegExp(validation_rules_default.httpUrlPattern);
-var PLACEHOLDER_PATTERN = toRegExp(validation_rules_default.placeholderPattern);
-var ALLOWED_STACKS = validation_rules_default.allowedStacks;
-var ALWAYS_ALLOWED_TAGS = validation_rules_default.alwaysAllowedTags;
-var PATTERN_TAG_SUFFIXES = validation_rules_default.patternTagSuffixes;
-var ALLOWED_SET = new Set([...ALLOWED_STACKS, ...ALWAYS_ALLOWED_TAGS].map((t) => t.toLowerCase()));
-function isTagAllowed(tag) {
-  const lower = tag.toLowerCase();
-  if (ALLOWED_SET.has(lower)) return true;
-  return PATTERN_TAG_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+async function fetchText(url) {
+  return fetchGuarded(url, (res) => res.text());
 }
-function auditDisallowedTags(items) {
-  const failures = [];
-  for (const item of items) {
-    if (!item.id) continue;
-    for (const tag of Array.isArray(item.tags) ? item.tags : []) {
-      if (!isTagAllowed(tag)) failures.push(`${item.id}: tag not in allowlist: "${tag}"`);
-    }
+async function fetchBytes(url) {
+  return fetchGuarded(url, async (res) => Buffer.from(await res.arrayBuffer()));
+}
+async function writeTextIfChanged(dest, text) {
+  if (await fs2.pathExists(dest)) {
+    const local = await fs2.readFile(dest, "utf8");
+    if (local === text) return "unchanged";
+    await fs2.writeFile(dest, text, "utf8");
+    return "updated";
   }
-  return failures;
+  await fs2.ensureDir(path4.dirname(dest));
+  await fs2.writeFile(dest, text, "utf8");
+  return "created";
 }
 
-// src/catalog/forbidden-content.ts
-var PROSE_FORBIDDEN_TAGS = FORBIDDEN_TAGS.filter((t) => t.toLowerCase() !== "go");
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// src/catalog/remote-catalog/ref.ts
+import os2 from "node:os";
+import path5 from "node:path";
+import fs3 from "fs-extra";
+function isTestMode() {
+  return process.env["HAUS_TEST_MODE"] === "1" || process.env["NODE_ENV"] === "test";
 }
-function extractUseWhenSection(text) {
-  const marker = "## Use when";
-  const idx = text.toLowerCase().indexOf(marker.toLowerCase());
-  if (idx < 0) return "";
-  const tail = text.slice(idx + marker.length);
-  const next = tail.search(/\n##\s+/);
-  return next < 0 ? tail : tail.slice(0, next);
+function getCacheDir() {
+  return process.env["HAUS_CATALOG_CACHE_DIR_OVERRIDE"] ?? path5.join(os2.homedir(), CATALOG_CACHE_SUBDIR);
 }
-function isYamlBlockScalarHeader(rest) {
-  return /^[>|][-+]?(\d+)?(?:\s+#.*)?$/.test(rest);
+var cachedCatalogRef;
+var inFlightCatalogRef;
+function getBundledCatalogRef() {
+  try {
+    const manifestPath2 = path5.join(packageRoot(), "library/catalog/manifest.json");
+    const raw = fs3.readFileSync(manifestPath2, "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data.version === "string" && data.version) {
+      return data.version.startsWith("v") ? data.version : `v${data.version}`;
+    }
+  } catch {
+  }
+  return void 0;
 }
-function extractFrontmatterValue(text, key) {
-  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!m) return "";
-  const lines = m[1].split(/\r?\n/);
-  const keyRe = new RegExp(`^${escapeRegExp(key)}:[ \\t]*`);
-  const idx = lines.findIndex((l) => keyRe.test(l));
-  if (idx < 0) return "";
-  const rest = lines[idx].replace(keyRe, "").trim();
-  if (!rest) return "";
-  if (!isYamlBlockScalarHeader(rest)) {
-    return rest.replace(/^["']|["']$/g, "").trim();
+function getResolvedCatalogRef() {
+  const resolved = cachedCatalogRef ?? process.env["HAUS_CATALOG_REF"] ?? getBundledCatalogRef();
+  if (!resolved) {
+    warn(
+      "Could not determine catalog ref from cache, env, or bundled snapshot \u2014 falling back to main (moving target)."
+    );
+    return "main";
   }
-  const body = [];
-  for (let j = idx + 1; j < lines.length; j++) {
-    const line2 = lines[j];
-    if (/^[a-zA-Z_][\w.-]*:[ \t]/.test(line2)) break;
-    if (line2.trim() === "") continue;
-    if (/^\s+/.test(line2)) body.push(line2.trimStart());
-    else break;
+  return resolved;
+}
+function isCatalogRefResolved() {
+  return cachedCatalogRef !== void 0 || process.env["HAUS_CATALOG_REF"] !== void 0;
+}
+var CATALOG_TAGS_API_URL = "https://api.github.com/repos/WeAreHausTech/haus-workflow-catalog/tags";
+function parseSemverTag(tag) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(tag);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(a, b) {
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] !== b[i]) return a[i] - b[i];
   }
-  return body.join(" ").replace(/\s+/g, " ").trim();
+  return 0;
 }
-function extractFrontmatterDescription(text) {
-  return extractFrontmatterValue(text, "description");
+function githubApiHeaders() {
+  const headers = { Accept: "application/vnd.github+json" };
+  const auth = process.env["HAUS_GITHUB_TOKEN"] ?? process.env["GITHUB_TOKEN"];
+  if (auth) headers["Authorization"] = `Bearer ${auth}`;
+  return headers;
 }
-function auditForbiddenTagsInText(text, label) {
-  const body = `${extractFrontmatterDescription(text)}
-${extractUseWhenSection(text)}`;
-  if (!body.trim()) return [];
-  const failures = [];
-  for (const word of PROSE_FORBIDDEN_TAGS) {
-    const re = new RegExp(`\\b${escapeRegExp(word)}\\b`, "i");
-    if (re.test(body)) failures.push(`${label}: forbidden stack/tag "${word}" in content`);
+async function fetchLatestCatalogTag() {
+  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) return null;
+  try {
+    const res = await fetch(CATALOG_TAGS_API_URL, {
+      signal: AbortSignal.timeout(5e3),
+      headers: githubApiHeaders()
+    });
+    if (!res.ok) return null;
+    const tags = await res.json();
+    const valid = tags.map((tag) => {
+      const name = typeof tag.name === "string" ? tag.name : "";
+      const semver2 = parseSemverTag(name);
+      return semver2 ? { name, semver: semver2 } : null;
+    }).filter(
+      (entry) => entry !== null
+    );
+    if (valid.length === 0) return null;
+    valid.sort((a, b) => compareSemver(b.semver, a.semver));
+    return valid[0].name;
+  } catch {
+    return null;
   }
-  return failures;
+}
+async function resolveCatalogRef(opts) {
+  const env = opts?.env ?? process.env;
+  if (env["HAUS_CATALOG_REF"]) {
+    if (env["HAUS_CATALOG_REF"] === "main") {
+      warn(
+        "HAUS_CATALOG_REF=main is set \u2014 fetching from the moving main branch. Pin to a release tag for reproducible installs."
+      );
+    }
+    return env["HAUS_CATALOG_REF"];
+  }
+  const fetchLatest = opts?.fetchLatestTag ?? fetchLatestCatalogTag;
+  const tag = await fetchLatest();
+  if (tag !== null) return tag;
+  const fallback = opts?.fallbackRef;
+  if (fallback) {
+    warn(
+      `Tag resolution failed \u2014 using cached ref ${fallback}. To use latest, retry or set HAUS_CATALOG_REF explicitly.`
+    );
+    return fallback;
+  }
+  const bundled = getBundledCatalogRef();
+  if (bundled) {
+    warn(
+      `Tag resolution failed \u2014 using bundled snapshot ref ${bundled}. To use latest, retry or set HAUS_CATALOG_REF explicitly.`
+    );
+    return bundled;
+  }
+  warn(
+    "Tag resolution failed and no fallback ref is available. Set HAUS_CATALOG_REF explicitly to avoid fetching from main."
+  );
+  return "main";
+}
+async function remoteBase() {
+  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
+    return process.env["HAUS_CATALOG_REMOTE_BASE"];
+  }
+  if (cachedCatalogRef === void 0) {
+    if (!inFlightCatalogRef) {
+      inFlightCatalogRef = resolveCatalogRef({ fallbackRef: getBundledCatalogRef() }).then(
+        (ref) => {
+          cachedCatalogRef = ref;
+          return ref;
+        }
+      );
+    }
+    await inFlightCatalogRef;
+  }
+  return `${CATALOG_REPO_URL}/${cachedCatalogRef}`;
 }
 
-// src/catalog/ingest-catalog.ts
-function validateCatalogItem(item, content2) {
-  const label = item.id;
-  const checkNonTsxNpx = !isNpxTsxOnlyExempt(item.type, item.source);
-  const lines = content2.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line2 = lines[i] ?? "";
-    if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2))) {
-      return { ok: false, reason: `${label}: risky install pattern at line ${i + 1}` };
+// src/catalog/remote-catalog/github-tree.ts
+var cachedBlobPaths;
+var inFlightBlobPaths;
+function sanitizeRelativeFilePaths(files, label) {
+  const safe = [];
+  for (const rel of files) {
+    if (!isSafeRelativeFilePath(rel)) {
+      warn(`Rejected unsafe path in ${label}: ${rel}`);
+      return null;
     }
-    if (checkNonTsxNpx && ANY_NPX_PATTERN.test(line2) && !ALLOWED_NPX_PATTERN.test(line2)) {
-      return { ok: false, reason: `${label}: disallowed npx at line ${i + 1}` };
+    safe.push(rel);
+  }
+  return safe;
+}
+async function listFilesRecursive(dir, base = dir) {
+  const out = [];
+  let entries;
+  try {
+    if (!await fs4.pathExists(dir)) return out;
+    entries = await fs4.readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listFilesRecursive(full, base));
+    } else if (entry.isFile()) {
+      out.push(path6.relative(base, full).replace(/\\/g, "/"));
     }
   }
-  const tagFailures = auditForbiddenTagsInText(content2, label);
-  if (tagFailures.length > 0) {
-    return { ok: false, reason: tagFailures[0] };
+  return out.sort();
+}
+async function listMockPrefixFiles(base, prefix) {
+  const text = await fetchText(`${base}/__haus_tree__/${encodeURIComponent(prefix)}`);
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed) || !parsed.every((e) => typeof e === "string")) return null;
+    return parsed;
+  } catch {
+    return null;
   }
-  return { ok: true };
+}
+async function fetchGitHubRecursiveBlobPaths(ref) {
+  try {
+    const headers = githubApiHeaders();
+    const commitRes = await fetch(`${CATALOG_GITHUB_API_URL}/commits/${encodeURIComponent(ref)}`, {
+      signal: AbortSignal.timeout(15e3),
+      headers
+    });
+    if (!commitRes.ok) return null;
+    const commit = await commitRes.json();
+    const treeSha = commit.commit.tree.sha;
+    const treeRes = await fetch(`${CATALOG_GITHUB_API_URL}/git/trees/${treeSha}?recursive=1`, {
+      signal: AbortSignal.timeout(3e4),
+      headers
+    });
+    if (!treeRes.ok) return null;
+    const tree = await treeRes.json();
+    if (tree.truncated) {
+      warn("Catalog GitHub tree listing was truncated \u2014 refusing partial cache sync");
+      return null;
+    }
+    return tree.tree.filter((e) => e.type === "blob").map((e) => e.path);
+  } catch {
+    return null;
+  }
+}
+async function fetchCatalogBlobPaths(_base) {
+  if (cachedBlobPaths) return cachedBlobPaths;
+  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) return null;
+  if (!inFlightBlobPaths) {
+    inFlightBlobPaths = (async () => {
+      const ref = getResolvedCatalogRef();
+      const paths = await fetchGitHubRecursiveBlobPaths(ref);
+      if (paths) cachedBlobPaths = paths;
+      inFlightBlobPaths = void 0;
+      return paths;
+    })();
+  }
+  return inFlightBlobPaths;
+}
+async function listFilesUnderCatalogPrefix(prefix, base) {
+  const normalized = prefix.replace(/\\/g, "/").replace(/\/+$/, "");
+  const prefixSlash = `${normalized}/`;
+  let relFiles;
+  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
+    relFiles = await listMockPrefixFiles(base, normalized);
+  } else {
+    const blobs = await fetchCatalogBlobPaths(base);
+    if (!blobs) return null;
+    relFiles = blobs.filter((p) => p.startsWith(prefixSlash)).map((p) => p.slice(prefixSlash.length)).sort();
+  }
+  if (!relFiles) return null;
+  return sanitizeRelativeFilePaths(relFiles, normalized);
+}
+function _resetBlobPathCacheForNewSync() {
+  cachedBlobPaths = void 0;
+  inFlightBlobPaths = void 0;
 }
 
 // src/catalog/manifest-item-fields.ts
@@ -534,6 +545,42 @@ function validateReferences(itemId, references) {
   }
   return null;
 }
+function validateFormerIds(items) {
+  const failures = [];
+  const currentIds = new Set(items.map((item) => item.id).filter(Boolean));
+  const claimedBy = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const itemId = item.id ?? "unknown";
+    const formerIds = item.formerIds;
+    if (formerIds === void 0) continue;
+    if (Array.isArray(formerIds) && formerIds.length === 0) continue;
+    if (!isStringArray(formerIds)) {
+      failures.push(`${itemId}: formerIds must be a string array`);
+      continue;
+    }
+    const seenInItem = /* @__PURE__ */ new Set();
+    for (const formerId of formerIds) {
+      if (seenInItem.has(formerId)) {
+        failures.push(`${itemId}: duplicate formerId "${formerId}"`);
+        continue;
+      }
+      seenInItem.add(formerId);
+      if (formerId === itemId) {
+        failures.push(`${itemId}: formerIds must not include own current id`);
+      }
+      if (currentIds.has(formerId) && formerId !== itemId) {
+        failures.push(`${itemId}: formerId "${formerId}" conflicts with another item's current id`);
+      }
+      const previousOwner = claimedBy.get(formerId);
+      if (previousOwner !== void 0) {
+        failures.push(`formerId "${formerId}" claimed by both ${previousOwner} and ${itemId}`);
+      } else {
+        claimedBy.set(formerId, itemId);
+      }
+    }
+  }
+  return failures;
+}
 function validateCuratedProvenance(item) {
   if (item.source !== "curated") return null;
   if (!isNonEmptyString(item.reviewStatus)) {
@@ -648,264 +695,352 @@ function parseManifest(json) {
     if (typeof item.tokenEstimate !== "number" || !Number.isFinite(item.tokenEstimate)) {
       return { ok: false, error: `${item.id}: tokenEstimate must be a finite number` };
     }
+    if (item.formerIds !== void 0) {
+      if (Array.isArray(item.formerIds) && item.formerIds.length === 0) {
+      } else if (!isStringArray2(item.formerIds)) {
+        return { ok: false, error: `${item.id}: formerIds must be a string array` };
+      }
+    }
     items.push(raw);
   }
+  const formerIdFailures = validateFormerIds(items);
+  if (formerIdFailures.length > 0) {
+    return { ok: false, error: formerIdFailures[0] };
+  }
   return { ok: true, manifest: { version: root.version, items } };
 }
 
-// src/catalog/remote-catalog.ts
-function isTestMode() {
-  return process.env["HAUS_TEST_MODE"] === "1" || process.env["NODE_ENV"] === "test";
-}
-function getCacheDir() {
-  return process.env["HAUS_CATALOG_CACHE_DIR_OVERRIDE"] ?? path3.join(os2.homedir(), CATALOG_CACHE_SUBDIR);
-}
-var cachedCatalogRef;
-var cachedBlobPaths;
-function getBundledCatalogRef() {
-  try {
-    const manifestPath2 = path3.join(packageRoot(), "library/catalog/manifest.json");
-    const raw = fs2.readFileSync(manifestPath2, "utf8");
-    const data = JSON.parse(raw);
-    if (typeof data.version === "string" && data.version) {
-      return data.version.startsWith("v") ? data.version : `v${data.version}`;
-    }
-  } catch {
-  }
-  return void 0;
-}
-function getResolvedCatalogRef() {
-  const resolved = cachedCatalogRef ?? process.env["HAUS_CATALOG_REF"] ?? getBundledCatalogRef();
-  if (!resolved) {
-    warn(
-      "Could not determine catalog ref from cache, env, or bundled snapshot \u2014 falling back to main (moving target)."
-    );
-    return "main";
-  }
-  return resolved;
-}
-function isCatalogRefResolved() {
-  return cachedCatalogRef !== void 0 || process.env["HAUS_CATALOG_REF"] !== void 0;
-}
-async function resolveCatalogRef(opts) {
-  const env = opts?.env ?? process.env;
-  if (env["HAUS_CATALOG_REF"]) {
-    if (env["HAUS_CATALOG_REF"] === "main") {
-      warn(
-        "HAUS_CATALOG_REF=main is set \u2014 fetching from the moving main branch. Pin to a release tag for reproducible installs."
-      );
-    }
-    return env["HAUS_CATALOG_REF"];
-  }
-  const fetchLatest = opts?.fetchLatestTag ?? fetchLatestCatalogTag;
-  const tag = await fetchLatest();
-  if (tag !== null) return tag;
-  const fallback = opts?.fallbackRef;
-  if (fallback) {
-    warn(
-      `Tag resolution failed \u2014 using cached ref ${fallback}. To use latest, retry or set HAUS_CATALOG_REF explicitly.`
-    );
-    return fallback;
-  }
-  const bundled = getBundledCatalogRef();
-  if (bundled) {
-    warn(
-      `Tag resolution failed \u2014 using bundled snapshot ref ${bundled}. To use latest, retry or set HAUS_CATALOG_REF explicitly.`
-    );
-    return bundled;
-  }
-  warn(
-    "Tag resolution failed and no fallback ref is available. Set HAUS_CATALOG_REF explicitly to avoid fetching from main."
-  );
-  return "main";
-}
-async function remoteBase() {
-  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
-    return process.env["HAUS_CATALOG_REMOTE_BASE"];
-  }
-  if (cachedCatalogRef === void 0) {
-    cachedCatalogRef = await resolveCatalogRef({ fallbackRef: getBundledCatalogRef() });
-  }
-  return `${CATALOG_REPO_URL}/${cachedCatalogRef}`;
-}
-async function fetchText(url) {
-  try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
-    if (!res.ok) {
-      warn(`Catalog fetch HTTP ${res.status}: ${url}`);
-      return null;
-    }
-    return await res.text();
-  } catch (e) {
-    warn(`Catalog fetch failed (${e instanceof Error ? e.constructor.name : String(e)}): ${url}`);
-    return null;
-  }
-}
-async function fetchBytes(url) {
-  try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
-    if (!res.ok) {
-      warn(`Catalog fetch HTTP ${res.status}: ${url}`);
-      return null;
-    }
-    return Buffer.from(await res.arrayBuffer());
-  } catch (e) {
-    warn(`Catalog fetch failed (${e instanceof Error ? e.constructor.name : String(e)}): ${url}`);
-    return null;
-  }
-}
-async function fetchRemoteManifest() {
-  const base = await remoteBase();
-  const text = await fetchText(`${base}/manifest.json`);
-  if (!text) return null;
-  const parsed = parseManifest(text);
-  if (!parsed.ok) {
-    warn(`Remote manifest failed schema validation: ${parsed.error}`);
-    return null;
-  }
-  if (!parsed.manifest.items.length) return null;
-  return parsed.manifest;
-}
-async function writeTextIfChanged(dest, text) {
-  if (await fs2.pathExists(dest)) {
-    const local = await fs2.readFile(dest, "utf8");
-    if (local === text) return "unchanged";
-    await fs2.writeFile(dest, text, "utf8");
-    return "updated";
-  }
-  await fs2.ensureDir(path3.dirname(dest));
-  await fs2.writeFile(dest, text, "utf8");
-  return "created";
+// src/catalog/remote-catalog/manifest.ts
+async function fetchRemoteManifest() {
+  const base = await remoteBase();
+  const text = await fetchText(`${base}/manifest.json`);
+  if (!text) return null;
+  const parsed = parseManifest(text);
+  if (!parsed.ok) {
+    warn(`Remote manifest failed schema validation: ${parsed.error}`);
+    return null;
+  }
+  if (!parsed.manifest.items.length) return null;
+  return parsed.manifest;
 }
+
+// src/catalog/remote-catalog/workflow-template.ts
+import path7 from "node:path";
+import fs5 from "fs-extra";
 var WORKFLOW_TEMPLATE_REL = "templates/agentic-workflow-standard.md";
 async function readWorkflowTemplate(opts = {}) {
-  const dest = path3.join(getCacheDir(), WORKFLOW_TEMPLATE_REL);
+  const dest = path7.join(getCacheDir(), WORKFLOW_TEMPLATE_REL);
   const base = await remoteBase();
   const text = await fetchText(`${base}/${WORKFLOW_TEMPLATE_REL}`);
   if (text === null) {
-    if (await fs2.pathExists(dest)) return fs2.readFile(dest, "utf8");
+    if (await fs5.pathExists(dest)) return fs5.readFile(dest, "utf8");
     return null;
   }
   if (!opts.dryRun) {
     await writeTextIfChanged(dest, text);
-  } else if (await fs2.pathExists(dest)) {
-    return fs2.readFile(dest, "utf8");
   }
   return text;
 }
-function isSafeCatalogPath(itemPath) {
-  if (!itemPath || path3.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
-  const normalized = path3.normalize(itemPath);
-  return !normalized.startsWith("..") && !normalized.includes("/..");
+
+// src/catalog/remote-catalog/sync.ts
+import path8 from "node:path";
+import fs6 from "fs-extra";
+
+// library/catalog/validation-rules.json
+var validation_rules_default = {
+  forbiddenTags: [
+    "python",
+    "django",
+    "go",
+    "rust",
+    "java",
+    "spring",
+    "kotlin",
+    "swift",
+    "android",
+    "flutter",
+    "dart",
+    "c++",
+    "perl",
+    "defi",
+    "trading"
+  ],
+  requiredSkillFrontmatter: ["description"],
+  riskyInstallPatterns: [
+    { source: "\\bnpx\\s+-y\\b", flags: "i" },
+    { source: "\\bnpx\\s+--yes\\b", flags: "i" },
+    { source: "\\byarn\\s+dlx\\b", flags: "i" },
+    { source: "\\bpnpm\\s+dlx\\b", flags: "i" }
+  ],
+  allowedNpxPattern: { source: "\\bnpx\\s+tsx\\b", flags: "i" },
+  anyNpxPattern: { source: "\\bnpx\\s+\\S+", flags: "i" },
+  npxTsxOnlyExemptSources: ["curated"],
+  httpUrlPattern: { source: "^http:\\/\\/", flags: "i" },
+  placeholderPattern: { source: "\\bTODO\\b|\\bPLACEHOLDER\\b", flags: "i" },
+  allowedStacks: [
+    "haus",
+    "security",
+    "quality",
+    "frontend",
+    "backend",
+    "testing",
+    "review",
+    "workflow",
+    "reference-pack",
+    "core-skill",
+    "workflow-skill",
+    "stack-skill",
+    "review-skill",
+    "agent",
+    "hook",
+    "rule",
+    "react",
+    "typescript",
+    "php",
+    "csharp",
+    "vendure",
+    "vendure3",
+    "nestjs",
+    "graphql",
+    "nx",
+    "turbo",
+    "nextjs",
+    "react19",
+    "typescript5",
+    "vite8",
+    "tanstack-query",
+    "tanstack-router",
+    "radix",
+    "radix-ui",
+    "shadcn",
+    "shadcn-ui",
+    "tailwind",
+    "tailwindcss",
+    "scss",
+    "scss-modules",
+    "vue",
+    "expressjs",
+    "laravel",
+    "laravel-nova",
+    "wordpress",
+    "bedrock",
+    "elementor-pro",
+    "acf-pro",
+    "jetengine",
+    "dotnet",
+    "oidc",
+    "azure-ad",
+    "bankid",
+    "crypto",
+    "postgresql",
+    "mariadb",
+    "mssql",
+    "elasticsearch",
+    "yarn4",
+    "pnpm89",
+    "playwright",
+    "testing-library",
+    "phpunit",
+    "storybook",
+    "vitest",
+    "jest",
+    "redis",
+    "sanity",
+    "strapi",
+    "prisma",
+    "cms",
+    "database",
+    "mysql",
+    "saml2",
+    "next-auth",
+    "auth",
+    "expo",
+    "react-native",
+    "mobile",
+    "i18next",
+    "i18n",
+    "bullmq",
+    "queue",
+    "sentry",
+    "observability",
+    "tooling",
+    "prettier",
+    "eslint",
+    "missing-prettier",
+    "missing-eslint",
+    "docker",
+    "pm2",
+    "stripe",
+    "qliro",
+    "supabase",
+    "payments",
+    "myid",
+    "cgi",
+    "collection2",
+    "deployer-php"
+  ],
+  safetyNotesRequiredTags: [
+    "stripe",
+    "qliro",
+    "payments",
+    "bankid",
+    "myid",
+    "oidc",
+    "azure-ad",
+    "saml2"
+  ],
+  intentsRequiredTags: [
+    "stripe",
+    "qliro",
+    "payments",
+    "bankid",
+    "myid",
+    "oidc",
+    "azure-ad",
+    "saml2"
+  ],
+  alwaysAllowedTags: [
+    "haus",
+    "security",
+    "quality",
+    "review",
+    "workflow",
+    "baseline",
+    "project-instructions"
+  ],
+  patternTagSuffixes: ["-patterns"]
+};
+
+// src/catalog/validation-rules.ts
+var toRegExp = (r) => new RegExp(r.source, r.flags);
+var FORBIDDEN_TAGS = validation_rules_default.forbiddenTags;
+var REQUIRED_SKILL_FRONTMATTER = validation_rules_default.requiredSkillFrontmatter;
+var RISKY_INSTALL_PATTERNS = validation_rules_default.riskyInstallPatterns.map(toRegExp);
+var ALLOWED_NPX_PATTERN = toRegExp(validation_rules_default.allowedNpxPattern);
+var ANY_NPX_PATTERN = toRegExp(validation_rules_default.anyNpxPattern);
+var NPX_TSX_ONLY_EXEMPT_SOURCES = validation_rules_default.npxTsxOnlyExemptSources ?? [];
+function isNpxTsxOnlyExempt(_itemType, itemSource) {
+  return Boolean(itemSource && NPX_TSX_ONLY_EXEMPT_SOURCES.includes(itemSource));
 }
-function isSafeRelativeFilePath(rel) {
-  if (!rel || rel.startsWith("/") || rel.includes("\\") || rel.includes("//")) return false;
-  if (path3.isAbsolute(rel)) return false;
-  const normalized = path3.posix.normalize(rel.replace(/\\/g, "/"));
-  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+function buildItemPathSourceMap(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!item.path) continue;
+    map.set(String(item.path).replace(/\\/g, "/"), item.source);
+  }
+  return map;
 }
-function githubApiHeaders() {
-  const headers = { Accept: "application/vnd.github+json" };
-  const auth = process.env["HAUS_GITHUB_TOKEN"] ?? process.env["GITHUB_TOKEN"];
-  if (auth) headers["Authorization"] = `Bearer ${auth}`;
-  return headers;
+function resolveMarkdownItemSource(relPath, pathSourceMap) {
+  const norm = relPath.replace(/\\/g, "/");
+  let cursor = norm;
+  while (true) {
+    if (pathSourceMap.has(cursor)) return pathSourceMap.get(cursor);
+    const slash = cursor.lastIndexOf("/");
+    if (slash === -1) break;
+    cursor = cursor.slice(0, slash);
+  }
+  return void 0;
 }
-function sanitizeRelativeFilePaths(files, label) {
-  const safe = [];
-  for (const rel of files) {
-    if (!isSafeRelativeFilePath(rel)) {
-      warn(`Rejected unsafe path in ${label}: ${rel}`);
-      return null;
+var HTTP_URL_PATTERN = toRegExp(validation_rules_default.httpUrlPattern);
+var PLACEHOLDER_PATTERN = toRegExp(validation_rules_default.placeholderPattern);
+var ALLOWED_STACKS = validation_rules_default.allowedStacks;
+var ALWAYS_ALLOWED_TAGS = validation_rules_default.alwaysAllowedTags;
+var PATTERN_TAG_SUFFIXES = validation_rules_default.patternTagSuffixes;
+var ALLOWED_SET = new Set([...ALLOWED_STACKS, ...ALWAYS_ALLOWED_TAGS].map((t) => t.toLowerCase()));
+function isTagAllowed(tag) {
+  const lower = tag.toLowerCase();
+  if (ALLOWED_SET.has(lower)) return true;
+  return PATTERN_TAG_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+}
+function auditDisallowedTags(items) {
+  const failures = [];
+  for (const item of items) {
+    if (!item.id) continue;
+    for (const tag of Array.isArray(item.tags) ? item.tags : []) {
+      if (!isTagAllowed(tag)) failures.push(`${item.id}: tag not in allowlist: "${tag}"`);
     }
-    safe.push(rel);
   }
-  return safe;
+  return failures;
 }
-function safeJoin(base, itemPath) {
-  if (!isSafeCatalogPath(itemPath)) return null;
-  const resolved = path3.resolve(base, itemPath);
-  return resolved.startsWith(base + path3.sep) || resolved === base ? resolved : null;
+
+// src/catalog/forbidden-content.ts
+var PROSE_FORBIDDEN_TAGS = FORBIDDEN_TAGS.filter((t) => t.toLowerCase() !== "go");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var KNOWN_ITEM_TYPES = /* @__PURE__ */ new Set(["skill", "agent", "template", "command", "config"]);
-function isMarkdownPath(rel) {
-  return rel.toLowerCase().endsWith(".md");
+function extractUseWhenSection(text) {
+  const marker = "## Use when";
+  const idx = text.toLowerCase().indexOf(marker.toLowerCase());
+  if (idx < 0) return "";
+  const tail = text.slice(idx + marker.length);
+  const next = tail.search(/\n##\s+/);
+  return next < 0 ? tail : tail.slice(0, next);
 }
-async function listFilesRecursive(dir, base = dir) {
-  const out = [];
-  let entries;
-  try {
-    if (!await fs2.pathExists(dir)) return out;
-    entries = await fs2.readdir(dir, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const full = path3.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      out.push(...await listFilesRecursive(full, base));
-    } else if (entry.isFile()) {
-      out.push(path3.relative(base, full).replace(/\\/g, "/"));
-    }
+function isYamlBlockScalarHeader(rest) {
+  return /^[>|][-+]?(\d+)?(?:\s+#.*)?$/.test(rest);
+}
+function extractFrontmatterValue(text, key) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return "";
+  const lines = m[1].split(/\r?\n/);
+  const keyRe = new RegExp(`^${escapeRegExp(key)}:[ \\t]*`);
+  const idx = lines.findIndex((l) => keyRe.test(l));
+  if (idx < 0) return "";
+  const rest = lines[idx].replace(keyRe, "").trim();
+  if (!rest) return "";
+  if (!isYamlBlockScalarHeader(rest)) {
+    return rest.replace(/^["']|["']$/g, "").trim();
   }
-  return out.sort();
+  const body = [];
+  for (let j = idx + 1; j < lines.length; j++) {
+    const line2 = lines[j];
+    if (/^[a-zA-Z_][\w.-]*:[ \t]/.test(line2)) break;
+    if (line2.trim() === "") continue;
+    if (/^\s+/.test(line2)) body.push(line2.trimStart());
+    else break;
+  }
+  return body.join(" ").replace(/\s+/g, " ").trim();
 }
-async function listMockPrefixFiles(base, prefix) {
-  const text = await fetchText(`${base}/__haus_tree__/${encodeURIComponent(prefix)}`);
-  if (text === null) return null;
-  try {
-    const parsed = JSON.parse(text);
-    if (!Array.isArray(parsed) || !parsed.every((e) => typeof e === "string")) return null;
-    return parsed;
-  } catch {
-    return null;
+function extractFrontmatterDescription(text) {
+  return extractFrontmatterValue(text, "description");
+}
+function auditForbiddenTagsInText(text, label) {
+  const body = `${extractFrontmatterDescription(text)}
+${extractUseWhenSection(text)}`;
+  if (!body.trim()) return [];
+  const failures = [];
+  for (const word of PROSE_FORBIDDEN_TAGS) {
+    const re = new RegExp(`\\b${escapeRegExp(word)}\\b`, "i");
+    if (re.test(body)) failures.push(`${label}: forbidden stack/tag "${word}" in content`);
   }
+  return failures;
 }
-async function fetchGitHubRecursiveBlobPaths(ref) {
-  try {
-    const headers = githubApiHeaders();
-    const commitRes = await fetch(`${CATALOG_GITHUB_API_URL}/commits/${encodeURIComponent(ref)}`, {
-      signal: AbortSignal.timeout(15e3),
-      headers
-    });
-    if (!commitRes.ok) return null;
-    const commit = await commitRes.json();
-    const treeSha = commit.commit.tree.sha;
-    const treeRes = await fetch(`${CATALOG_GITHUB_API_URL}/git/trees/${treeSha}?recursive=1`, {
-      signal: AbortSignal.timeout(3e4),
-      headers
-    });
-    if (!treeRes.ok) return null;
-    const tree = await treeRes.json();
-    if (tree.truncated) {
-      warn("Catalog GitHub tree listing was truncated \u2014 refusing partial cache sync");
-      return null;
+
+// src/catalog/ingest-catalog.ts
+function validateCatalogItem(item, content2) {
+  const label = item.id;
+  const checkNonTsxNpx = !isNpxTsxOnlyExempt(item.type, item.source);
+  const lines = content2.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line2 = lines[i] ?? "";
+    if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2))) {
+      return { ok: false, reason: `${label}: risky install pattern at line ${i + 1}` };
+    }
+    if (checkNonTsxNpx && ANY_NPX_PATTERN.test(line2) && !ALLOWED_NPX_PATTERN.test(line2)) {
+      return { ok: false, reason: `${label}: disallowed npx at line ${i + 1}` };
     }
-    return tree.tree.filter((e) => e.type === "blob").map((e) => e.path);
-  } catch {
-    return null;
   }
-}
-async function fetchCatalogBlobPaths(_base) {
-  if (cachedBlobPaths) return cachedBlobPaths;
-  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) return null;
-  const ref = getResolvedCatalogRef();
-  const paths = await fetchGitHubRecursiveBlobPaths(ref);
-  if (paths) cachedBlobPaths = paths;
-  return paths;
-}
-async function listFilesUnderCatalogPrefix(prefix, base) {
-  const normalized = prefix.replace(/\\/g, "/").replace(/\/+$/, "");
-  const prefixSlash = `${normalized}/`;
-  let relFiles;
-  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
-    relFiles = await listMockPrefixFiles(base, normalized);
-  } else {
-    const blobs = await fetchCatalogBlobPaths(base);
-    if (!blobs) return null;
-    relFiles = blobs.filter((p) => p.startsWith(prefixSlash)).map((p) => p.slice(prefixSlash.length)).sort();
+  const tagFailures = auditForbiddenTagsInText(content2, label);
+  if (tagFailures.length > 0) {
+    return { ok: false, reason: tagFailures[0] };
   }
-  if (!relFiles) return null;
-  return sanitizeRelativeFilePaths(relFiles, normalized);
+  return { ok: true };
+}
+
+// src/catalog/remote-catalog/sync.ts
+var KNOWN_ITEM_TYPES = /* @__PURE__ */ new Set(["skill", "agent", "template", "command", "config"]);
+function isMarkdownPath(rel) {
+  return rel.toLowerCase().endsWith(".md");
 }
 async function fetchPrefixFiles(catalogPrefix, relFiles, base, label) {
   const fetched = [];
@@ -941,7 +1076,7 @@ function validateMarkdownFiles(item, fetched) {
   return true;
 }
 async function directoryMatchesFetched(destDir, fetched) {
-  if (!await fs2.pathExists(destDir)) return false;
+  if (!await fs6.pathExists(destDir)) return false;
   const existing = await listFilesRecursive(destDir);
   const relSet = new Set(fetched.map((f) => f.rel));
   if (existing.length !== fetched.length) return false;
@@ -949,30 +1084,30 @@ async function directoryMatchesFetched(destDir, fetched) {
     if (!relSet.has(rel)) return false;
   }
   for (const file of fetched) {
-    const dest = path3.join(destDir, file.rel);
-    if (!await fs2.pathExists(dest)) return false;
+    const dest = path8.join(destDir, file.rel);
+    if (!await fs6.pathExists(dest)) return false;
     if (file.kind === "text") {
-      const local = await fs2.readFile(dest, "utf8");
+      const local = await fs6.readFile(dest, "utf8");
       if (local !== file.body) return false;
     } else {
-      const local = await fs2.readFile(dest);
+      const local = await fs6.readFile(dest);
       if (!local.equals(file.body)) return false;
     }
   }
   return true;
 }
 async function writeFetchedDirectory(destDir, fetched) {
-  if (await fs2.pathExists(destDir)) {
-    await fs2.remove(destDir);
+  if (await fs6.pathExists(destDir)) {
+    await fs6.remove(destDir);
   }
-  await fs2.ensureDir(destDir);
+  await fs6.ensureDir(destDir);
   for (const file of fetched) {
-    const dest = path3.join(destDir, file.rel);
-    await fs2.ensureDir(path3.dirname(dest));
+    const dest = path8.join(destDir, file.rel);
+    await fs6.ensureDir(path8.dirname(dest));
     if (file.kind === "text") {
-      await fs2.writeFile(dest, file.body, "utf8");
+      await fs6.writeFile(dest, file.body, "utf8");
     } else {
-      await fs2.writeFile(dest, file.body);
+      await fs6.writeFile(dest, file.body);
     }
   }
 }
@@ -1012,7 +1147,7 @@ async function syncDirectoryFromPrefix(item, catalogPrefix, destDir, base, opts)
       }
     }
   }
-  const existed = await fs2.pathExists(destDir);
+  const existed = await fs6.pathExists(destDir);
   if (await directoryMatchesFetched(destDir, fetched)) {
     return "unchanged";
   }
@@ -1129,7 +1264,7 @@ async function syncOneItem(item, base) {
   }
 }
 async function syncRemoteCatalog() {
-  cachedBlobPaths = void 0;
+  _resetBlobPathCacheForNewSync();
   const manifest = await fetchRemoteManifest();
   if (!manifest) {
     warn("Remote catalog fetch failed \u2014 using bundled catalog");
@@ -1138,9 +1273,9 @@ async function syncRemoteCatalog() {
   const { version, items } = manifest;
   const cacheDir = getCacheDir();
   try {
-    await fs2.ensureDir(cacheDir);
-    await fs2.writeFile(
-      path3.join(cacheDir, "manifest.json"),
+    await fs6.ensureDir(cacheDir);
+    await fs6.writeFile(
+      path8.join(cacheDir, "manifest.json"),
       `${JSON.stringify({ version, items }, null, 2)}
 `,
       "utf8"
@@ -1171,44 +1306,9 @@ async function syncRemoteCatalog() {
   }
   return { newItems, refreshed, unchanged, failed };
 }
-var CATALOG_TAGS_API_URL = "https://api.github.com/repos/WeAreHausTech/haus-workflow-catalog/tags";
-function parseSemverTag(tag) {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(tag);
-  if (!match) return null;
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function compareSemver(a, b) {
-  for (let i = 0; i < 3; i += 1) {
-    if (a[i] !== b[i]) return a[i] - b[i];
-  }
-  return 0;
-}
-async function fetchLatestCatalogTag() {
-  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) return null;
-  try {
-    const res = await fetch(CATALOG_TAGS_API_URL, {
-      signal: AbortSignal.timeout(5e3),
-      headers: githubApiHeaders()
-    });
-    if (!res.ok) return null;
-    const tags = await res.json();
-    const valid = tags.map((tag) => {
-      const name = typeof tag.name === "string" ? tag.name : "";
-      const semver2 = parseSemverTag(name);
-      return semver2 ? { name, semver: semver2 } : null;
-    }).filter(
-      (entry) => entry !== null
-    );
-    if (valid.length === 0) return null;
-    valid.sort((a, b) => compareSemver(b.semver, a.semver));
-    return valid[0].name;
-  } catch {
-    return null;
-  }
-}
 async function getCacheManifestAge() {
   try {
-    const stat = await fs2.stat(path3.join(getCacheDir(), "manifest.json"));
+    const stat = await fs6.stat(path8.join(getCacheDir(), "manifest.json"));
     return Date.now() - stat.mtimeMs;
   } catch {
     return null;
@@ -1222,30 +1322,30 @@ async function loadCatalogContext(root) {
     const data2 = await readJson(envPath);
     return {
       items: data2?.items ?? [],
-      contentRoot: path4.dirname(envPath),
+      contentRoot: path9.dirname(envPath),
       source: "fixture"
     };
   }
   const cacheDir = getCacheDir();
-  const cacheManifestPath = path4.join(cacheDir, "manifest.json");
+  const cacheManifestPath = path9.join(cacheDir, "manifest.json");
   const cacheData = await readJson(cacheManifestPath);
   if (cacheData?.items?.length) {
     return { items: cacheData.items, contentRoot: cacheDir, source: "cache" };
   }
-  const localManifest = path4.join(root, "library/catalog/manifest.json");
+  const localManifest = path9.join(root, "library/catalog/manifest.json");
   const localData = await readJson(localManifest);
   if (localData?.items?.length) {
     return {
       items: localData.items,
-      contentRoot: path4.dirname(localManifest),
+      contentRoot: path9.dirname(localManifest),
       source: "local"
     };
   }
-  const packageManifest = path4.join(packageRoot(), "library/catalog/manifest.json");
+  const packageManifest = path9.join(packageRoot(), "library/catalog/manifest.json");
   const data = await readJson(packageManifest);
   return {
     items: data?.items ?? [],
-    contentRoot: path4.dirname(packageManifest),
+    contentRoot: path9.dirname(packageManifest),
     source: "bundled"
   };
 }
@@ -1254,17 +1354,70 @@ async function loadCatalog(root) {
   return ctx.items;
 }
 function catalogItemContentPath(contentRoot, item) {
-  return path4.join(contentRoot, item.path);
+  return path9.join(contentRoot, item.path);
 }
 
 // src/claude/write-claude-files.ts
-import path14 from "node:path";
-import fs14 from "fs-extra";
+import path19 from "node:path";
+import fs18 from "fs-extra";
+
+// src/catalog/former-ids.ts
+function normalizeFormerIds(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length === 0) return [];
+  if (!value.every((entry) => typeof entry === "string")) return [];
+  return value.filter((entry) => entry.length > 0);
+}
+function assertFormerIdsShape(itemId, formerIds) {
+  if (formerIds === void 0) return;
+  if (Array.isArray(formerIds) && formerIds.length === 0) return;
+  if (!Array.isArray(formerIds) || !formerIds.every((entry) => typeof entry === "string")) {
+    throw new Error(`${itemId}: formerIds must be a string array`);
+  }
+}
+function buildFormerIdMap(items) {
+  const map = /* @__PURE__ */ new Map();
+  const currentIds = new Set(items.map((item) => item.id));
+  for (const item of items) {
+    assertFormerIdsShape(item.id, item.formerIds);
+    const formerIds = item.formerIds ?? [];
+    if (!Array.isArray(formerIds) || formerIds.length === 0) continue;
+    for (const formerId of formerIds) {
+      if (currentIds.has(formerId) && formerId !== item.id) {
+        throw new Error(
+          `formerId ${formerId} on ${item.id} conflicts with another item's current id`
+        );
+      }
+      const existingOwner = map.get(formerId);
+      if (existingOwner !== void 0) {
+        throw new Error(
+          `duplicate formerId ${formerId} claimed by both ${existingOwner} and ${item.id}`
+        );
+      }
+      map.set(formerId, item.id);
+    }
+  }
+  return map;
+}
+function findFormerIdMigrations(lockItems, manifestItems) {
+  const formerIdMap = buildFormerIdMap(manifestItems);
+  return lockItems.flatMap(({ id }) => {
+    const newId = formerIdMap.get(id);
+    return newId === void 0 ? [] : [{ oldId: id, newId }];
+  });
+}
+
+// src/recommender/orphaned-items.ts
+function findOrphanedLockEntries(lock, recommendedIds) {
+  return lock.filter(
+    (entry) => typeof entry.id === "string" && !recommendedIds.has(entry.id)
+  );
+}
 
 // src/update/hash-installed.ts
-import path5 from "node:path";
+import path10 from "node:path";
 import fg2 from "fast-glob";
-import fs3 from "fs-extra";
+import fs7 from "fs-extra";
 
 // src/claude/haus-managed-header.ts
 function parseHausManagedAttrs(line2) {
@@ -1303,6 +1456,14 @@ function parseHausManagedHeader(line2) {
 
 // src/update/hash-installed.ts
 var EMPTY_LOCK_PATHS_TOKEN = "haus-lock:empty-paths";
+function digestFileContent(buf) {
+  const asText = buf.toString("utf8");
+  const roundTrip = Buffer.from(asText, "utf8");
+  if (roundTrip.equals(buf)) {
+    return hashText(normaliseLF(asText));
+  }
+  return hashText(buf);
+}
 async function hashInstalledPaths(root, relPaths) {
   if (relPaths.length === 0) {
     return hashText(EMPTY_LOCK_PATHS_TOKEN);
@@ -1310,21 +1471,21 @@ async function hashInstalledPaths(root, relPaths) {
   const normalized = [...new Set(relPaths.map((p) => p.replace(/\\/g, "/")))].sort();
   const fileDigests = [];
   for (const rel of normalized) {
-    const abs = path5.join(root, rel);
-    if (!await fs3.pathExists(abs)) continue;
-    const stat = await fs3.stat(abs);
+    const abs = path10.join(root, rel);
+    if (!await fs7.pathExists(abs)) continue;
+    const stat = await fs7.stat(abs);
     if (stat.isFile()) {
-      const body = await fs3.readFile(abs, "utf8");
-      fileDigests.push({ rel, digest: hashText(normaliseLF(body)) });
+      const body = await fs7.readFile(abs);
+      fileDigests.push({ rel, digest: digestFileContent(body) });
       continue;
     }
     if (!stat.isDirectory()) continue;
     const inner = await fg2("**/*", { cwd: abs, onlyFiles: true, dot: true });
     for (const sub of inner.sort()) {
-      const relFile = path5.join(rel, sub).replace(/\\/g, "/");
-      const absFile = path5.join(abs, sub);
-      const body = await fs3.readFile(absFile, "utf8");
-      fileDigests.push({ rel: relFile, digest: hashText(normaliseLF(body)) });
+      const relFile = path10.join(rel, sub).replace(/\\/g, "/");
+      const absFile = path10.join(abs, sub);
+      const body = await fs7.readFile(absFile);
+      fileDigests.push({ rel: relFile, digest: digestFileContent(body) });
     }
   }
   if (fileDigests.length === 0) {
@@ -1335,7 +1496,7 @@ async function hashInstalledPaths(root, relPaths) {
 }
 
 // src/claude/managed-write.ts
-import fs4 from "fs-extra";
+import fs8 from "fs-extra";
 
 // src/utils/diff.ts
 import { createTwoFilesPatch } from "diff";
@@ -1361,10 +1522,11 @@ function summarizeDiff(diffText) {
 
 // src/claude/managed-write.ts
 async function writeManagedText(root, filePath, nextText, dryRun) {
-  const prev = await fs4.pathExists(filePath) ? await fs4.readFile(filePath, "utf8") : "";
+  const existed = await fs8.pathExists(filePath);
+  const prev = existed ? await fs8.readFile(filePath, "utf8") : "";
   const printable = displayPath(root, filePath);
   if (dryRun) {
-    if (!prev) {
+    if (!existed) {
       log(createUnifiedDiff(printable, "", nextText));
     } else if (hasTextChanged(prev, nextText)) {
       log(createUnifiedDiff(printable, prev, nextText));
@@ -1373,12 +1535,14 @@ async function writeManagedText(root, filePath, nextText, dryRun) {
     }
     return;
   }
-  if (hasTextChanged(prev, nextText) && prev.length > 0) {
-    const diffText = createUnifiedDiff(printable, prev, nextText);
-    const summary = summarizeDiff(diffText);
-    log(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
+  if (!existed || hasTextChanged(prev, nextText)) {
+    if (existed) {
+      const diffText = createUnifiedDiff(printable, prev, nextText);
+      const summary = summarizeDiff(diffText);
+      log(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
+    }
+    await writeText(filePath, nextText);
   }
-  await writeText(filePath, nextText);
 }
 async function writeManagedJson(root, filePath, value, dryRun) {
   const nextText = `${JSON.stringify(value, null, 2)}
@@ -1393,18 +1557,18 @@ function buildAllowRules() {
 }
 
 // src/install/settings-merge.ts
-import path7 from "node:path";
-import fs5 from "fs-extra";
+import path12 from "node:path";
+import fs9 from "fs-extra";
 
 // src/install/manifest.ts
 import os3 from "node:os";
-import path6 from "node:path";
+import path11 from "node:path";
 var MANIFEST_SCHEMA = "haus-install-manifest/1";
 function globalClaudeDir() {
-  return path6.join(os3.homedir(), ".claude");
+  return path11.join(os3.homedir(), ".claude");
 }
 function hausManifestPath() {
-  return path6.join(globalClaudeDir(), "haus", "install-manifest.json");
+  return path11.join(globalClaudeDir(), "haus", "install-manifest.json");
 }
 async function readManifest() {
   return readJson(hausManifestPath());
@@ -1424,7 +1588,7 @@ function buildManifest(source, files, hooks) {
 
 // src/install/settings-merge.ts
 function settingsJsonPath() {
-  return path7.join(globalClaudeDir(), "settings.json");
+  return path12.join(globalClaudeDir(), "settings.json");
 }
 async function readSettings() {
   const filePath = settingsJsonPath();
@@ -1539,77 +1703,62 @@ function reconcileManagedRules(existing, prevTracked, newRules) {
   const removed = existing.filter((rule) => !newSet.has(rule));
   return { rules: [...userRules, ...tracked], tracked, added, removed };
 }
+function createRuleTier(permKey, trackedKey) {
+  function merge(settings, rules) {
+    const existing = settings.permissions?.[permKey] ?? [];
+    const tracked = settings._haus?.[trackedKey] ?? [];
+    const {
+      rules: nextRules,
+      tracked: nextTracked,
+      added
+    } = reconcileManagedRules(existing, tracked, rules);
+    const updated = { ...settings };
+    updated.permissions = { ...settings.permissions ?? {}, [permKey]: nextRules };
+    updated._haus = {
+      hooks: settings._haus?.hooks ?? [],
+      ...settings._haus?.hookCommands ? { hookCommands: settings._haus.hookCommands } : {},
+      ...permKey !== "deny" && settings._haus?.denyRules ? { denyRules: settings._haus.denyRules } : {},
+      ...permKey !== "allow" && settings._haus?.allowRules ? { allowRules: settings._haus.allowRules } : {},
+      ...permKey !== "ask" && settings._haus?.askRules ? { askRules: settings._haus.askRules } : {},
+      [trackedKey]: nextTracked
+    };
+    return { settings: updated, addedRules: added };
+  }
+  function strip(settings) {
+    const prevHaus = settings._haus;
+    const ownedRules = prevHaus?.[trackedKey];
+    if (!ownedRules || ownedRules.length === 0) return settings;
+    const ownedSet = new Set(ownedRules);
+    const updated = { ...settings };
+    const remaining = (settings.permissions?.[permKey] ?? []).filter((rule) => !ownedSet.has(rule));
+    const permissions = { ...settings.permissions ?? {} };
+    if (remaining.length > 0) permissions[permKey] = remaining;
+    else delete permissions[permKey];
+    if (Object.keys(permissions).length > 0) updated.permissions = permissions;
+    else delete updated.permissions;
+    const haus = { ...prevHaus };
+    delete haus[trackedKey];
+    const stillTracking = (haus.hooks?.length ?? 0) > 0 || (haus.hookCommands?.length ?? 0) > 0 || (haus.denyRules?.length ?? 0) > 0 || (haus.allowRules?.length ?? 0) > 0 || (haus.askRules?.length ?? 0) > 0;
+    if (stillTracking) updated._haus = haus;
+    else delete updated._haus;
+    return updated;
+  }
+  return { merge, strip };
+}
+var denyTier = createRuleTier("deny", "denyRules");
+var allowTier = createRuleTier("allow", "allowRules");
+var askTier = createRuleTier("ask", "askRules");
 function mergeDenyRules(settings, rules) {
-  const existingDeny = settings.permissions?.deny ?? [];
-  const trackedDeny = settings._haus?.denyRules ?? [];
-  const { rules: deny, tracked, added } = reconcileManagedRules(existingDeny, trackedDeny, rules);
-  const updated = { ...settings };
-  updated.permissions = {
-    ...settings.permissions ?? {},
-    deny
-  };
-  updated._haus = {
-    hooks: settings._haus?.hooks ?? [],
-    ...settings._haus?.hookCommands ? { hookCommands: settings._haus.hookCommands } : {},
-    denyRules: tracked,
-    ...settings._haus?.allowRules ? { allowRules: settings._haus.allowRules } : {},
-    ...settings._haus?.askRules ? { askRules: settings._haus.askRules } : {}
-  };
-  return { settings: updated, addedRules: added };
+  return denyTier.merge(settings, rules);
 }
 function mergeAllowRules(settings, rules) {
-  const existingAllow = settings.permissions?.allow ?? [];
-  const trackedAllow = settings._haus?.allowRules ?? [];
-  const { rules: allow, tracked, added } = reconcileManagedRules(existingAllow, trackedAllow, rules);
-  const updated = { ...settings };
-  updated.permissions = {
-    ...settings.permissions ?? {},
-    allow
-  };
-  updated._haus = {
-    hooks: settings._haus?.hooks ?? [],
-    ...settings._haus?.hookCommands ? { hookCommands: settings._haus.hookCommands } : {},
-    ...settings._haus?.denyRules ? { denyRules: settings._haus.denyRules } : {},
-    allowRules: tracked,
-    ...settings._haus?.askRules ? { askRules: settings._haus.askRules } : {}
-  };
-  return { settings: updated, addedRules: added };
+  return allowTier.merge(settings, rules);
 }
 function stripHausAllow(settings) {
-  const prevHaus = settings._haus;
-  if (!prevHaus?.allowRules || prevHaus.allowRules.length === 0) return settings;
-  const ownedSet = new Set(prevHaus.allowRules);
-  const updated = { ...settings };
-  const remainingAllow = (settings.permissions?.allow ?? []).filter((rule) => !ownedSet.has(rule));
-  const permissions = { ...settings.permissions ?? {} };
-  if (remainingAllow.length > 0) permissions.allow = remainingAllow;
-  else delete permissions.allow;
-  if (Object.keys(permissions).length > 0) updated.permissions = permissions;
-  else delete updated.permissions;
-  const haus = { ...prevHaus };
-  delete haus.allowRules;
-  const stillTracking = (haus.hooks?.length ?? 0) > 0 || (haus.hookCommands?.length ?? 0) > 0 || (haus.denyRules?.length ?? 0) > 0 || (haus.askRules?.length ?? 0) > 0;
-  if (stillTracking) updated._haus = haus;
-  else delete updated._haus;
-  return updated;
+  return allowTier.strip(settings);
 }
 function stripHausDeny(settings) {
-  const prevHaus = settings._haus;
-  if (!prevHaus?.denyRules || prevHaus.denyRules.length === 0) return settings;
-  const ownedSet = new Set(prevHaus.denyRules);
-  const updated = { ...settings };
-  const remainingDeny = (settings.permissions?.deny ?? []).filter((rule) => !ownedSet.has(rule));
-  const permissions = { ...settings.permissions ?? {} };
-  if (remainingDeny.length > 0) permissions.deny = remainingDeny;
-  else delete permissions.deny;
-  if (Object.keys(permissions).length > 0) updated.permissions = permissions;
-  else delete updated.permissions;
-  const haus = { ...prevHaus };
-  delete haus.denyRules;
-  const stillTracking = (haus.hooks?.length ?? 0) > 0 || (haus.hookCommands?.length ?? 0) > 0 || (haus.allowRules?.length ?? 0) > 0 || (haus.askRules?.length ?? 0) > 0;
-  if (stillTracking) updated._haus = haus;
-  else delete updated._haus;
-  return updated;
+  return denyTier.strip(settings);
 }
 function stripHausHooks(settings) {
   if (!settings._haus) return settings;
@@ -1631,45 +1780,15 @@ function stripHausHooks(settings) {
   return rest;
 }
 function mergeAskRules(settings, rules) {
-  const existingAsk = settings.permissions?.ask ?? [];
-  const trackedAsk = settings._haus?.askRules ?? [];
-  const { rules: ask2, tracked, added } = reconcileManagedRules(existingAsk, trackedAsk, rules);
-  const updated = { ...settings };
-  updated.permissions = {
-    ...settings.permissions ?? {},
-    ask: ask2
-  };
-  updated._haus = {
-    hooks: settings._haus?.hooks ?? [],
-    ...settings._haus?.hookCommands ? { hookCommands: settings._haus.hookCommands } : {},
-    ...settings._haus?.denyRules ? { denyRules: settings._haus.denyRules } : {},
-    ...settings._haus?.allowRules ? { allowRules: settings._haus.allowRules } : {},
-    askRules: tracked
-  };
-  return { settings: updated, addedRules: added };
+  return askTier.merge(settings, rules);
 }
 function stripHausAsk(settings) {
-  const prevHaus = settings._haus;
-  if (!prevHaus?.askRules || prevHaus.askRules.length === 0) return settings;
-  const ownedSet = new Set(prevHaus.askRules);
-  const updated = { ...settings };
-  const remainingAsk = (settings.permissions?.ask ?? []).filter((rule) => !ownedSet.has(rule));
-  const permissions = { ...settings.permissions ?? {} };
-  if (remainingAsk.length > 0) permissions.ask = remainingAsk;
-  else delete permissions.ask;
-  if (Object.keys(permissions).length > 0) updated.permissions = permissions;
-  else delete updated.permissions;
-  const haus = { ...prevHaus };
-  delete haus.askRules;
-  const stillTracking = (haus.hooks?.length ?? 0) > 0 || (haus.hookCommands?.length ?? 0) > 0 || (haus.denyRules?.length ?? 0) > 0 || (haus.allowRules?.length ?? 0) > 0;
-  if (stillTracking) updated._haus = haus;
-  else delete updated._haus;
-  return updated;
+  return askTier.strip(settings);
 }
 async function loadHooksFragment(fragmentPath) {
   let raw;
   try {
-    raw = await fs5.readJson(fragmentPath);
+    raw = await fs9.readJson(fragmentPath);
   } catch {
     return [];
   }
@@ -1784,8 +1903,8 @@ function buildDenyRules() {
   for (const command of DENY_COMMANDS) {
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path46 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path46) ? `${path46}/**` : path46;
+  for (const path54 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path54) ? `${path54}/**` : path54;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -1857,9 +1976,9 @@ async function applyProjectSettingsMerge(root) {
 }
 
 // src/claude/superpowers-install.ts
-import path8 from "node:path";
+import path13 from "node:path";
 import fg3 from "fast-glob";
-import fs6 from "fs-extra";
+import fs10 from "fs-extra";
 var SUPERPOWERS_ORIGIN_SOURCE_ID = "superpowers-pcvelz";
 var PATH_REWRITES = [
   ["skills/shared/", ".claude/skills/shared/"]
@@ -1874,41 +1993,41 @@ function rewriteSuperpowersMarkdown(text) {
 async function rewriteMarkdownTree(dir) {
   const files = await fg3("**/*.md", { cwd: dir, onlyFiles: true, dot: true });
   for (const rel of files) {
-    const abs = path8.join(dir, rel);
-    const text = await fs6.readFile(abs, "utf8");
+    const abs = path13.join(dir, rel);
+    const text = await fs10.readFile(abs, "utf8");
     const rewritten = rewriteSuperpowersMarkdown(text);
     if (rewritten !== text) {
-      await fs6.writeFile(abs, rewritten, "utf8");
+      await fs10.writeFile(abs, rewritten, "utf8");
     }
   }
 }
 async function installCatalogSkill(sourcePath, destination, opts) {
   if (opts.dryRun) return;
-  await fs6.ensureDir(path8.dirname(destination));
-  if (await fs6.pathExists(destination)) {
-    await fs6.remove(destination);
+  await fs10.ensureDir(path13.dirname(destination));
+  if (await fs10.pathExists(destination)) {
+    await fs10.remove(destination);
   }
-  await fs6.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+  await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
   if (opts.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID) {
     await rewriteMarkdownTree(destination);
   }
 }
 async function installSuperpowersShared(contentRoot, projectRoot, dryRun) {
-  const source = path8.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
-  if (!await fs6.pathExists(source)) return null;
+  const source = path13.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
+  if (!await fs10.pathExists(source)) return null;
   const destination = claudePath(projectRoot, "skills", "shared");
-  if (dryRun) return path8.relative(projectRoot, destination);
-  await fs6.ensureDir(path8.dirname(destination));
-  if (await fs6.pathExists(destination)) {
-    await fs6.remove(destination);
+  if (dryRun) return path13.relative(projectRoot, destination);
+  await fs10.ensureDir(path13.dirname(destination));
+  if (await fs10.pathExists(destination)) {
+    await fs10.remove(destination);
   }
-  await fs6.copy(source, destination, { overwrite: true, errorOnExist: false });
+  await fs10.copy(source, destination, { overwrite: true, errorOnExist: false });
   await rewriteMarkdownTree(destination);
-  return path8.relative(projectRoot, destination);
+  return path13.relative(projectRoot, destination);
 }
 
 // src/claude/verify-hooks-contract.ts
-import fs7 from "fs-extra";
+import fs11 from "fs-extra";
 
 // src/claude/load-hooks.ts
 var CANONICAL_HOOKS = {
@@ -1988,7 +2107,7 @@ async function assertPostApplySettingsHausContract(root) {
 }
 async function verifyProjectSettingsHooksContract(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs7.pathExists(settingsPath)) {
+  if (!await fs11.pathExists(settingsPath)) {
     return {
       ok: true,
       skipped: true,
@@ -2015,8 +2134,8 @@ async function verifyProjectSettingsHooksContract(root) {
 }
 
 // src/claude/write-decisions-seed.ts
-import path9 from "node:path";
-import fs8 from "fs-extra";
+import path14 from "node:path";
+import fs12 from "fs-extra";
 
 // library/catalog/decisions-triggers.json
 var decisions_triggers_default = {
@@ -2059,24 +2178,36 @@ Why we chose X \u2014 short, dated, write-once decision log for humans and agent
 | --- | ----- | -------------- | ------ |
 `;
 async function writeDecisionsSeed(root, dryRun) {
-  const decisionsDir = path9.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const readmePath = path9.join(decisionsDir, "README.md");
-  if (await fs8.pathExists(readmePath)) return null;
-  if (!dryRun) await fs8.ensureDir(decisionsDir);
+  const decisionsDir = path14.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const readmePath = path14.join(decisionsDir, "README.md");
+  if (await fs12.pathExists(readmePath)) return null;
+  if (!dryRun) await fs12.ensureDir(decisionsDir);
   await writeManagedText(root, readmePath, SEED_README, dryRun);
   return readmePath;
 }
 
 // src/claude/write-prettierignore.ts
-import path10 from "node:path";
-import fs9 from "fs-extra";
+import path15 from "node:path";
+import fs13 from "fs-extra";
 var PRETTIERIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var PRETTIERIGNORE_END = "# HAUS:END haus-managed";
-var IGNORED_PATHS = [".haus-workflow/"];
+var IGNORED_PATHS = [".haus-workflow/", ".claude/"];
+function prettierIgnoreProtects(lines, dir) {
+  const bare = dir.replace(/\/+$/, "");
+  const equivalents = /* @__PURE__ */ new Set([
+    bare,
+    `${bare}/`,
+    `/${bare}`,
+    `/${bare}/`,
+    `${bare}/**`,
+    `/${bare}/**`
+  ]);
+  return lines.some((line2) => equivalents.has(line2.trim()));
+}
 function buildPrettierIgnoreBlock() {
   return [
     PRETTIERIGNORE_BEGIN,
-    "# haus-owned files \u2014 do not reformat (keeps tamper-detection hashes stable)",
+    "# haus-owned files \u2014 do not reformat (keeps tamper/lock hashes stable)",
     ...IGNORED_PATHS,
     PRETTIERIGNORE_END
   ].join("\n");
@@ -2125,16 +2256,16 @@ ${block}
 `;
 }
 async function writePrettierIgnore(root, dryRun) {
-  const filePath = path10.join(root, ".prettierignore");
-  const prev = await fs9.pathExists(filePath) ? await fs9.readFile(filePath, "utf8") : "";
+  const filePath = path15.join(root, ".prettierignore");
+  const prev = await fs13.pathExists(filePath) ? await fs13.readFile(filePath, "utf8") : "";
   const next = injectPrettierIgnoreBlock(prev, buildPrettierIgnoreBlock());
   await writeManagedText(root, filePath, next, dryRun);
   return filePath;
 }
 
 // src/claude/write-root-claude-md.ts
-import path11 from "node:path";
-import fs10 from "fs-extra";
+import path16 from "node:path";
+import fs14 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
 var IMPORT_CONTENT = `@.haus-workflow/WORKFLOW.md
@@ -2165,12 +2296,20 @@ function findImportBlockRange(content2) {
 }
 function stripHausBlock(existing) {
   const range = findImportBlockRange(existing);
-  if (!range) return existing;
-  const before = existing.slice(0, range.beginStart);
-  const after = existing.slice(range.endEnd);
-  const merged = `${before}${after}`.replace(/\n{3,}/g, "\n\n").trimEnd();
-  return merged.length > 0 ? `${merged}
+  if (range) {
+    const before = existing.slice(0, range.beginStart);
+    const after = existing.slice(range.endEnd);
+    const merged = `${before}${after}`.replace(/\n{3,}/g, "\n\n").trimEnd();
+    return merged.length > 0 ? `${merged}
+` : "";
+  }
+  const loneBegin = findLineMarker2(existing, BLOCK_BEGIN);
+  if (loneBegin) {
+    const before = existing.slice(0, loneBegin.start).trimEnd();
+    return before.length > 0 ? `${before}
 ` : "";
+  }
+  return existing;
 }
 function injectHausBlock(existing, block) {
   const range = findImportBlockRange(existing);
@@ -2200,21 +2339,21 @@ ${block}
 `;
 }
 async function writeRootClaudeMd(root, dryRun) {
-  const filePath = path11.join(root, "CLAUDE.md");
+  const filePath = path16.join(root, "CLAUDE.md");
   const block = buildImportBlock();
-  const prev = await fs10.pathExists(filePath) ? await fs10.readFile(filePath, "utf8") : "";
+  const prev = await fs14.pathExists(filePath) ? await fs14.readFile(filePath, "utf8") : "";
   const next = injectHausBlock(prev, block);
   await writeManagedText(root, filePath, next, dryRun);
   return filePath;
 }
 
 // src/claude/write-workflow-config.ts
-import path13 from "node:path";
-import fs12 from "fs-extra";
+import path18 from "node:path";
+import fs16 from "fs-extra";
 
 // src/claude/derive-workflow-config.ts
-import path12 from "node:path";
-import fs11 from "fs-extra";
+import path17 from "node:path";
+import fs15 from "fs-extra";
 function binCmd(pm, bin, args) {
   const tail = args ? ` ${args}` : "";
   if (pm === "yarn") return `yarn ${bin}${tail}`;
@@ -2223,7 +2362,7 @@ function binCmd(pm, bin, args) {
 }
 async function deriveWorkflowConfig(root, ctx) {
   const pm = ctx.packageManager === "unknown" ? "npm" : ctx.packageManager;
-  const pkg = await readJson(path12.join(root, "package.json"));
+  const pkg = await readJson(path17.join(root, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = new Set(ctx.dependencies);
   const stacks = Object.values(ctx.detectedStacks ?? {}).flat();
@@ -2233,7 +2372,7 @@ async function deriveWorkflowConfig(root, ctx) {
     return null;
   };
   const hasDep = (name) => deps.has(name);
-  const exists = (rel) => fs11.pathExistsSync(path12.join(root, rel));
+  const exists = (rel) => fs15.pathExistsSync(path17.join(root, rel));
   const hasPlaywright = hasDep("@playwright/test") || stacks.includes("playwright");
   const hasCypress = hasDep("cypress");
   const preCommitTool = exists("lefthook.yml") || exists("lefthook.yaml") ? "lefthook" : exists(".husky") || hasDep("husky") || (scripts.prepare ?? "").includes("husky") ? "husky" : exists(".pre-commit-config.yaml") ? "pre-commit (Python framework)" : null;
@@ -2301,7 +2440,7 @@ var FALLBACK_CONTEXT = {
 async function writeWorkflowConfig(root, dryRun, opts = {}) {
   const destPath = hausPath(root, "workflow-config.md");
   const printable = displayPath(root, destPath);
-  const exists = await fs12.pathExists(destPath);
+  const exists = await fs16.pathExists(destPath);
   if (exists && !opts.refill) {
     if (dryRun) log(printable + ": exists (project-owned, skipping)");
     return null;
@@ -2309,11 +2448,11 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   const ctx = await readJson(hausPath(root, "context-map.json")) ?? {
     ...FALLBACK_CONTEXT,
     root,
-    repoName: path13.basename(root)
+    repoName: path18.basename(root)
   };
   const values = await deriveWorkflowConfig(root, ctx);
   if (exists) {
-    const current = await fs12.readFile(destPath, "utf8");
+    const current = await fs16.readFile(destPath, "utf8");
     const refilled = refillContent(current, values);
     if (refilled === current) {
       if (dryRun) log(printable + ": no blank fields to refill");
@@ -2335,7 +2474,23 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
 }
 
 // src/claude/write-workflow.ts
-import fs13 from "fs-extra";
+import fs17 from "fs-extra";
+
+// src/claude/managed-tamper.ts
+function checkManagedTamper(body, storedHash, templateContent) {
+  const bodyHash = hashText(normaliseLF(body));
+  if (storedHash) {
+    if (bodyHash !== storedHash) return { status: "tampered" };
+    if (templateContent === null) return { status: "ok" };
+    const currentTemplateHash2 = hashText(normaliseLF(templateContent));
+    return storedHash !== currentTemplateHash2 ? { status: "stale" } : { status: "ok" };
+  }
+  if (templateContent === null) return { status: "legacy-ok" };
+  const currentTemplateHash = hashText(normaliseLF(templateContent));
+  return bodyHash === currentTemplateHash ? { status: "legacy-ok" } : { status: "legacy-diverged" };
+}
+
+// src/claude/write-workflow.ts
 var STABLE_ID = "template.workflow";
 function makeWorkflowHeader(pkgVersion, contentHash) {
   return `<!-- HAUS-MANAGED id=${STABLE_ID} v=${SCHEMA_VERSION} source=@haus-tech/haus-workflow@${pkgVersion} hash=${contentHash} -->`;
@@ -2354,8 +2509,8 @@ async function writeWorkflow(root, pkgVersion, dryRun, force = false) {
 ${templateContent}`;
   const destPath = hausPath(root, "WORKFLOW.md");
   const printable = displayPath(root, destPath);
-  if (await fs13.pathExists(destPath)) {
-    const existing = await fs13.readFile(destPath, "utf8");
+  if (await fs17.pathExists(destPath)) {
+    const existing = await fs17.readFile(destPath, "utf8");
     const firstLine = existing.split("\n")[0] ?? "";
     const parsed = parseHausManagedHeader(firstLine);
     if (!parsed) {
@@ -2373,32 +2528,25 @@ ${templateContent}`;
       return null;
     }
     const existingContent = existing.slice(firstLine.length + 1);
-    const bodyMatchesTemplate = hashText(normaliseLF(existingContent)) === contentHash;
-    if (parsed.hash) {
-      const bodyIntact = hashText(normaliseLF(existingContent)) === parsed.hash;
-      if (!bodyIntact && !force) {
-        warn(`${printable}: content modified by user \u2014 skipping. Use --force to overwrite.`);
-        return null;
-      }
-    } else {
-      if (!bodyMatchesTemplate && !force) {
-        const migratedHeader = makeWorkflowHeader(
-          pkgVersion,
-          hashText(normaliseLF(existingContent))
-        );
-        const migrated = `${migratedHeader}
+    const verdict = checkManagedTamper(existingContent, parsed.hash, templateContent);
+    if (verdict.status === "tampered" && !force) {
+      warn(`${printable}: content modified by user \u2014 skipping. Use --force to overwrite.`);
+      return null;
+    }
+    if (verdict.status === "legacy-diverged" && !force) {
+      const migratedHeader = makeWorkflowHeader(pkgVersion, hashText(normaliseLF(existingContent)));
+      const migrated = `${migratedHeader}
 ${existingContent}`;
-        if (hasTextChanged(existing, migrated)) {
-          if (dryRun) {
-            log(`${printable}: migrating legacy hash header (body preserved)`);
-          } else {
-            await writeText(destPath, migrated);
-          }
-        } else if (dryRun) {
-          log(`${printable}: unchanged`);
+      if (hasTextChanged(existing, migrated)) {
+        if (dryRun) {
+          log(`${printable}: migrating legacy hash header (body preserved)`);
+        } else {
+          await writeText(destPath, migrated);
         }
-        return destPath;
+      } else if (dryRun) {
+        log(`${printable}: unchanged`);
       }
+      return destPath;
     }
     if (!hasTextChanged(existing, next)) {
       if (dryRun) log(`${printable}: unchanged`);
@@ -2406,7 +2554,7 @@ ${existingContent}`;
     }
   }
   if (dryRun) {
-    const prev = await fs13.pathExists(destPath) ? await fs13.readFile(destPath, "utf8") : "";
+    const prev = await fs17.pathExists(destPath) ? await fs17.readFile(destPath, "utf8") : "";
     if (!prev) {
       log(createUnifiedDiff(printable, "", next));
     } else {
@@ -2428,6 +2576,19 @@ function targetDirForType(type) {
   if (type === "skill") return "skills";
   return null;
 }
+async function removeLegacyManagedStub(root, relPathSegments, stub, dryRun, say) {
+  const target = claudePath(root, ...relPathSegments);
+  if (!await fs18.pathExists(target)) return;
+  const content2 = await fs18.readFile(target, "utf8");
+  if (content2 !== stub && content2 !== `${stub}
+` && content2 !== `${stub}\r
+`) return;
+  if (dryRun) {
+    say(`[dry-run] would remove stale ${displayPath(root, target)}`);
+  } else {
+    await fs18.remove(target);
+  }
+}
 async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   const say = opts.quiet ? () => {
   } : log;
@@ -2441,7 +2602,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     estimatedTokenReductionPct: 0
   };
   const pkgRoot = packageRoot();
-  const hausVersion2 = (await readJson(path14.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
+  const hausVersion2 = (await readJson(path19.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
   const coreFiles = [claudePath(root, "settings.json"), claudePath(root, "rules", "haus.md")];
   const rootClaudeMdPath = await writeRootClaudeMd(root, dryRun);
   const decisionsSeedPath = await writeDecisionsSeed(root, dryRun);
@@ -2465,34 +2626,20 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     await applyProjectSettingsMerge(root);
     await assertPostApplySettingsHausContract(root);
   }
-  const legacyReviewPath = claudePath(root, "commands", "haus-review.md");
-  if (await fs14.pathExists(legacyReviewPath)) {
-    const content2 = await fs14.readFile(legacyReviewPath, "utf8");
-    const stub = 'Run `haus context --task "code review"` then review diff.';
-    if (content2 === stub || content2 === `${stub}
-` || content2 === `${stub}\r
-`) {
-      if (dryRun) {
-        say(`[dry-run] would remove stale ${displayPath(root, legacyReviewPath)}`);
-      } else {
-        await fs14.remove(legacyReviewPath);
-      }
-    }
-  }
-  const legacyDoctorPath = claudePath(root, "commands", "haus-doctor.md");
-  if (await fs14.pathExists(legacyDoctorPath)) {
-    const content2 = await fs14.readFile(legacyDoctorPath, "utf8");
-    const stub = "Run `haus doctor`.";
-    if (content2 === stub || content2 === `${stub}
-` || content2 === `${stub}\r
-`) {
-      if (dryRun) {
-        say(`[dry-run] would remove stale ${displayPath(root, legacyDoctorPath)}`);
-      } else {
-        await fs14.remove(legacyDoctorPath);
-      }
-    }
-  }
+  await removeLegacyManagedStub(
+    root,
+    ["commands", "haus-review.md"],
+    'Run `haus context --task "code review"` then review diff.',
+    dryRun,
+    say
+  );
+  await removeLegacyManagedStub(
+    root,
+    ["commands", "haus-doctor.md"],
+    "Run `haus doctor`.",
+    dryRun,
+    say
+  );
   await writeManagedText(
     root,
     claudePath(root, "rules", "haus.md"),
@@ -2516,20 +2663,13 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     ].join("\n"),
     dryRun
   );
-  const legacySecurityPath = claudePath(root, "rules", "security.md");
-  if (await fs14.pathExists(legacySecurityPath)) {
-    const content2 = await fs14.readFile(legacySecurityPath, "utf8");
-    const stub = "- Never read secrets.\n- Block dangerous shell commands.";
-    if (content2 === stub || content2 === `${stub}
-` || content2 === `${stub}\r
-`) {
-      if (dryRun) {
-        say(`[dry-run] would remove stale ${displayPath(root, legacySecurityPath)}`);
-      } else {
-        await fs14.remove(legacySecurityPath);
-      }
-    }
-  }
+  await removeLegacyManagedStub(
+    root,
+    ["rules", "security.md"],
+    "- Never read secrets.\n- Block dangerous shell commands.",
+    dryRun,
+    say
+  );
   const LEGACY_PRUNED_ARTIFACTS = [
     "config.json",
     "selected-context.json",
@@ -2541,19 +2681,68 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   ];
   for (const rel of LEGACY_PRUNED_ARTIFACTS) {
     const legacyPath = hausPath(root, rel);
-    if (await fs14.pathExists(legacyPath)) {
+    if (await fs18.pathExists(legacyPath)) {
       if (dryRun) {
         say(`[dry-run] would remove stale ${displayPath(root, legacyPath)}`);
       } else {
-        await fs14.remove(legacyPath);
+        await fs18.remove(legacyPath);
       }
     }
   }
   const { items: manifestItems, contentRoot } = await loadCatalogContext(root);
   const manifestById = new Map(manifestItems.map((item) => [item.id, item]));
+  const prevLock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
+  const allMigrations = findFormerIdMigrations(
+    prevLock.filter((entry) => Boolean(entry.id)),
+    manifestItems
+  );
+  const migrations = allMigrations.filter(
+    (migration) => selectedIds === void 0 || selectedIds.includes(migration.oldId) || selectedIds.includes(migration.newId)
+  );
+  const migrationByOldId = new Map(
+    migrations.map((migration) => [migration.oldId, migration.newId])
+  );
+  const cleanupManifestById = new Map(manifestById);
+  for (const migration of allMigrations) {
+    const currentItem = manifestById.get(migration.newId);
+    if (currentItem) cleanupManifestById.set(migration.oldId, currentItem);
+  }
+  for (const migration of migrations) {
+    if (dryRun) {
+      say(`[dry-run] would migrate ${migration.oldId} \u2192 ${migration.newId} (upstream rename)`);
+    } else {
+      warn(`migrated ${migration.oldId} \u2192 ${migration.newId} (upstream rename)`);
+    }
+  }
+  await cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, opts.quiet);
   const installedPathsByItem = /* @__PURE__ */ new Map();
   const installedIds = /* @__PURE__ */ new Set();
-  const catalogItems = selectedIds !== void 0 ? rec.recommended.filter((r) => selectedIds.includes(r.id)) : rec.recommended;
+  const selectedCatalogItems = selectedIds !== void 0 ? rec.recommended.filter((r) => selectedIds.includes(r.id)) : rec.recommended;
+  const catalogItemsById = /* @__PURE__ */ new Map();
+  for (const recommended of selectedCatalogItems) {
+    const id = migrationByOldId.get(recommended.id) ?? recommended.id;
+    const manifestItem = manifestById.get(id);
+    catalogItemsById.set(id, {
+      ...recommended,
+      id,
+      type: manifestItem?.type ?? recommended.type
+    });
+  }
+  for (const migration of migrations) {
+    if (catalogItemsById.has(migration.newId)) continue;
+    const lockItem = prevLock.find((entry) => entry.id === migration.oldId);
+    const manifestItem = manifestById.get(migration.newId);
+    if (!lockItem || !manifestItem) continue;
+    catalogItemsById.set(migration.newId, {
+      id: migration.newId,
+      type: manifestItem.type,
+      reason: "migrated from former catalog id",
+      reasons: [{ code: "former-id", message: `Renamed from ${migration.oldId}` }],
+      selectionMode: "manual",
+      install: true
+    });
+  }
+  const catalogItems = [...catalogItemsById.values()];
   let curatedReviewStatusSkips = 0;
   let superpowersSharedInstalled = false;
   for (const item of catalogItems) {
@@ -2587,21 +2776,21 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       );
       continue;
     }
-    const destination = claudePath(root, target, path14.basename(sourcePath));
-    if (await fs14.pathExists(sourcePath)) {
+    const destination = claudePath(root, target, path19.basename(sourcePath));
+    if (await fs18.pathExists(sourcePath)) {
       if (dryRun) {
-        const exists = await fs14.pathExists(destination);
+        const exists = await fs18.pathExists(destination);
         say(
           `${displayPath(root, destination)}: ${exists ? "would overwrite" : "would create"} (${item.id})`
         );
       } else if (item.type === "skill") {
-        const skillFiles = (await fs14.readdir(sourcePath, { recursive: true })).filter(
+        const skillFiles = (await fs18.readdir(sourcePath, { recursive: true })).filter(
           (f) => typeof f === "string" && f.endsWith(".md")
         );
         let skillValid = true;
         for (const relFile of skillFiles) {
-          const mdPath = path14.join(sourcePath, relFile);
-          const mdContent = await fs14.readFile(mdPath, "utf8");
+          const mdPath = path19.join(sourcePath, relFile);
+          const mdContent = await fs18.readFile(mdPath, "utf8");
           const mdValidation = validateCatalogItem(
             {
               id: manifestItem.id,
@@ -2625,7 +2814,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           dryRun: false
         });
       } else {
-        const fileContent = await fs14.readFile(sourcePath, "utf8");
+        const fileContent = await fs18.readFile(sourcePath, "utf8");
         const validation = validateCatalogItem(
           {
             id: manifestItem.id,
@@ -2639,17 +2828,17 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           warn(`Skipping ${item.id}: pre-copy validation failed \u2014 ${validation.reason}`);
           continue;
         }
-        await fs14.ensureDir(path14.dirname(destination));
-        await fs14.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+        await fs18.ensureDir(path19.dirname(destination));
+        await fs18.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
-      const relPaths = [path14.relative(root, destination)];
+      const relPaths = [path19.relative(root, destination)];
       if (!superpowersSharedInstalled && manifestItem.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID && item.type === "skill") {
         const sharedRel = await installSuperpowersShared(contentRoot, root, dryRun);
         if (sharedRel) {
           superpowersSharedInstalled = true;
           relPaths.push(sharedRel);
-          files.push(path14.join(root, sharedRel));
+          files.push(path19.join(root, sharedRel));
         }
       }
       const current = installedPathsByItem.get(item.id) ?? [];
@@ -2666,12 +2855,21 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       `${curatedReviewStatusSkips} curated items skipped: reviewStatus is not approved \u2014 possible catalog field rename upstream`
     );
   }
-  await cleanupStaleCatalogItems(root, manifestById, dryRun, opts.quiet);
+  await cleanupStaleCatalogItems(root, cleanupManifestById, dryRun, opts.quiet);
+  if (opts.prune) {
+    const notOrphaned = new Set(rec.recommended.map((r) => r.id));
+    for (const migration of allMigrations) notOrphaned.add(migration.oldId);
+    for (const entry of prevLock) {
+      if (!entry.id) continue;
+      const manifestItem = manifestById.get(entry.id);
+      if (!manifestItem || manifestItem.reviewStatus === "deprecated") notOrphaned.add(entry.id);
+    }
+    await pruneOrphanedCatalogItems(root, prevLock, notOrphaned, dryRun, opts.quiet);
+  }
   if (dryRun) return [...new Set(files)];
   const installedItems = catalogItems.filter((r) => installedIds.has(r.id));
-  const prevLock = await readJson(hausPath(root, "haus.lock.json"));
   const prevRefById = new Map(
-    (prevLock ?? []).filter((e) => e.id && e.catalogRef).map((e) => [e.id, e.catalogRef])
+    prevLock.filter((e) => e.id && e.catalogRef).map((e) => [migrationByOldId.get(e.id) ?? e.id, e.catalogRef])
   );
   const lockCatalogRef = (itemId) => isCatalogRefResolved() ? getResolvedCatalogRef() : prevRefById.get(itemId) ?? getResolvedCatalogRef();
   const lock = await Promise.all(
@@ -2703,6 +2901,44 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   await writeManagedJson(root, hausPath(root, "haus.lock.json"), lock, false);
   return [...new Set(files)];
 }
+async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, quiet) {
+  const say = quiet ? () => {
+  } : log;
+  for (const migration of migrations) {
+    const entry = prevLock.find((candidate) => candidate.id === migration.oldId);
+    if (!entry) continue;
+    const relPaths = entry.paths ?? [];
+    const existing = [];
+    for (const rel of relPaths) {
+      if (await fs18.pathExists(path19.join(root, rel))) existing.push(rel);
+    }
+    if (existing.length === 0) continue;
+    if (entry.hash === void 0) {
+      warn(
+        `Former catalog item ${migration.oldId} has no lock hash \u2014 leaving old paths in place: ${existing.join(", ")}`
+      );
+      continue;
+    }
+    const currentHash = await hashInstalledPaths(root, existing);
+    if (currentHash !== entry.hash) {
+      warn(
+        `Former catalog item ${migration.oldId} was modified locally \u2014 leaving old paths in place: ${existing.join(", ")}`
+      );
+      continue;
+    }
+    for (const rel of existing) {
+      const abs = path19.join(root, rel);
+      if (dryRun) {
+        say(
+          `[dry-run] would remove renamed ${displayPath(root, abs)} (${migration.oldId} \u2192 ${migration.newId})`
+        );
+        continue;
+      }
+      await fs18.remove(abs);
+      await pruneEmptyDir(path19.dirname(abs));
+    }
+  }
+}
 async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet) {
   const say = quiet ? () => {
   } : log;
@@ -2718,7 +2954,7 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet) {
     if (relPaths.length === 0) continue;
     const existing = [];
     for (const rel of relPaths) {
-      if (await fs14.pathExists(path14.join(root, rel))) existing.push(rel);
+      if (await fs18.pathExists(path19.join(root, rel))) existing.push(rel);
     }
     if (existing.length === 0) continue;
     const pruneReason = deprecated ? "deprecated" : "stale";
@@ -2736,45 +2972,111 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet) {
       continue;
     }
     for (const rel of existing) {
-      const abs = path14.join(root, rel);
+      const abs = path19.join(root, rel);
       if (dryRun) {
         say(`[dry-run] would remove ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
         continue;
       }
-      await fs14.remove(abs);
-      await pruneEmptyDir(path14.dirname(abs));
+      await fs18.remove(abs);
+      await pruneEmptyDir(path19.dirname(abs));
       say(`Removed ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
     }
   }
 }
+async function backupBeforePrune(root, absPaths, say) {
+  if (absPaths.length === 0) return;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupRoot = hausPath(root, "backups", `prune-${stamp}`);
+  for (const abs of absPaths) {
+    if (!await fs18.pathExists(abs)) continue;
+    const rel = path19.relative(root, abs);
+    const backupPath = path19.join(backupRoot, rel);
+    await fs18.ensureDir(path19.dirname(backupPath));
+    await fs18.copy(abs, backupPath);
+  }
+  say(`Backed up ${absPaths.length} path(s) to ${path19.relative(root, backupRoot)} before pruning.`);
+}
+async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun, quiet) {
+  const say = quiet ? () => {
+  } : log;
+  const orphaned = findOrphanedLockEntries(prevLock, notOrphanedIds);
+  if (orphaned.length === 0) return;
+  const toRemove = [];
+  for (const entry of orphaned) {
+    if (!entry.id) continue;
+    const relPaths = entry.paths ?? [];
+    if (relPaths.length === 0) continue;
+    const existing = [];
+    for (const rel of relPaths) {
+      if (await fs18.pathExists(path19.join(root, rel))) existing.push(rel);
+    }
+    if (existing.length === 0) continue;
+    if (entry.hash === void 0) {
+      warn(
+        `Orphaned catalog item ${entry.id} has no lock hash \u2014 leaving in place: ${existing.join(", ")}`
+      );
+      continue;
+    }
+    const currentHash = await hashInstalledPaths(root, relPaths);
+    if (currentHash !== entry.hash) {
+      warn(
+        `Orphaned catalog item ${entry.id} was modified locally \u2014 leaving in place: ${existing.join(", ")}`
+      );
+      continue;
+    }
+    toRemove.push({ id: entry.id, existing });
+  }
+  if (toRemove.length === 0) return;
+  if (dryRun) {
+    for (const { id, existing } of toRemove) {
+      for (const rel of existing) {
+        say(`[dry-run] would prune orphaned ${displayPath(root, path19.join(root, rel))} (${id})`);
+      }
+    }
+    return;
+  }
+  const allAbsPaths = toRemove.flatMap(
+    ({ existing }) => existing.map((rel) => path19.join(root, rel))
+  );
+  await backupBeforePrune(root, allAbsPaths, say);
+  for (const { id, existing } of toRemove) {
+    for (const rel of existing) {
+      const abs = path19.join(root, rel);
+      await fs18.remove(abs);
+      await pruneEmptyDir(path19.dirname(abs));
+      say(`Pruned orphaned ${displayPath(root, abs)} (${id})`);
+    }
+  }
+}
 
 // src/refs/fetch-refs.ts
-import path16 from "node:path";
-import fs16 from "fs-extra";
+import path21 from "node:path";
+import fs20 from "fs-extra";
 
 // src/refs/cache-meta.ts
-import path15 from "node:path";
-import fs15 from "fs-extra";
+import path20 from "node:path";
+import fs19 from "fs-extra";
 var META_FILENAME = "cache-meta.json";
 async function readCacheMeta(cacheDir) {
-  const metaPath = path15.join(cacheDir, META_FILENAME);
+  const metaPath = path20.join(cacheDir, META_FILENAME);
   try {
-    const raw = await fs15.readFile(metaPath, "utf8");
+    const raw = await fs19.readFile(metaPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 async function writeCacheMeta(cacheDir, meta) {
-  await fs15.ensureDir(cacheDir);
-  const metaPath = path15.join(cacheDir, META_FILENAME);
-  await fs15.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await fs19.ensureDir(cacheDir);
+  const metaPath = path20.join(cacheDir, META_FILENAME);
+  await fs19.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
 }
 
 // src/refs/fetch-refs.ts
 function urlToSlug(url) {
   const u = new URL(url);
-  return (u.host + u.pathname).replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  const protocolPrefix = u.protocol === "https:" ? "" : `${u.protocol.replace(":", "")}-`;
+  return (protocolPrefix + u.host + u.pathname).replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
 }
 function isLlmsTxtUrl(ref) {
   try {
@@ -2787,8 +3089,8 @@ function isLlmsTxtUrl(ref) {
 async function fetchSingleRef(url, cacheDir, meta) {
   const existing = meta[url];
   const headers = {};
-  const safeFile = existing?.file && existing.file === path16.basename(existing.file);
-  const cachedFileExists = safeFile && await fs16.pathExists(path16.join(cacheDir, existing.file));
+  const safeFile = existing?.file && existing.file === path21.basename(existing.file);
+  const cachedFileExists = safeFile && await fs20.pathExists(path21.join(cacheDir, existing.file));
   if (cachedFileExists) {
     if (existing?.etag) headers["If-None-Match"] = existing.etag;
     if (existing?.lastModified) headers["If-Modified-Since"] = existing.lastModified;
@@ -2799,8 +3101,8 @@ async function fetchSingleRef(url, cacheDir, meta) {
     if (!res.ok) return { result: "failed" };
     const text = await res.text();
     const file = `${urlToSlug(url)}.md`;
-    await fs16.ensureDir(cacheDir);
-    await fs16.writeFile(path16.join(cacheDir, file), text, "utf8");
+    await fs20.ensureDir(cacheDir);
+    await fs20.writeFile(path21.join(cacheDir, file), text, "utf8");
     meta[url] = {
       url,
       etag: res.headers.get("etag") ?? void 0,
@@ -2823,8 +3125,8 @@ async function pruneOrphanedRefs(cacheDir, keepUrls) {
     if (keepUrls.has(url)) continue;
     delete meta[url];
     removed++;
-    const safeFile = typeof entry.file === "string" && entry.file === path16.basename(entry.file);
-    if (safeFile) await fs16.remove(path16.join(cacheDir, entry.file)).catch(() => {
+    const safeFile = typeof entry.file === "string" && entry.file === path21.basename(entry.file);
+    if (safeFile) await fs20.remove(path21.join(cacheDir, entry.file)).catch(() => {
     });
   }
   if (removed > 0) await writeCacheMeta(cacheDir, meta);
@@ -2846,10 +3148,10 @@ async function fetchRefsForItems(items, cacheDir) {
       const outcome = await fetchSingleRef(url, cacheDir, meta);
       if (outcome.result === "fetched") {
         summary.fetched++;
-        summary.cachedFiles[url] = path16.join(cacheDir, outcome.file);
+        summary.cachedFiles[url] = path21.join(cacheDir, outcome.file);
       } else if (outcome.result === "unchanged") {
         summary.unchanged++;
-        if (meta[url]?.file) summary.cachedFiles[url] = path16.join(cacheDir, meta[url].file);
+        if (meta[url]?.file) summary.cachedFiles[url] = path21.join(cacheDir, meta[url].file);
       } else {
         summary.failed++;
         summary.failedUrls.push(url);
@@ -2870,8 +3172,9 @@ function parseIdList(value) {
 }
 
 // src/commands/apply.ts
+var STALE_CACHE_THRESHOLD_DAYS = 7;
 async function cacheHasItems() {
-  const data = await readJson(path17.join(getCacheDir(), "manifest.json"));
+  const data = await readJson(path22.join(getCacheDir(), "manifest.json"));
   return Array.isArray(data?.items) && data.items.length > 0;
 }
 function installableRecommendedItems(recommended) {
@@ -2944,56 +3247,428 @@ async function runApply(options) {
       }
     }
   }
-  if (!options.allowEmptyCache && !process.env["HAUS_FIXTURE_CATALOG"]) {
-    const rec = await readJson(hausPath(root, "recommendation.json"));
-    const installableRecommended = installableRecommendedItems(rec?.recommended ?? []);
-    const catalogItemCount = selectedIds !== void 0 ? selectedIds.length : installableRecommended.length;
-    if (catalogItemCount > 0 && !await cacheHasItems()) {
-      const message = "No catalog content found. Run `haus update` first.";
-      if (isDryRun) {
-        warn(`Catalog cache is empty \u2014 dry-run will skip catalog items. ${message}`);
-      } else {
-        error(message);
-        process.exitCode = 1;
-        return;
-      }
+  if (!process.env["HAUS_FIXTURE_CATALOG"]) {
+    const rec = await readJson(hausPath(root, "recommendation.json"));
+    const installableRecommended = installableRecommendedItems(rec?.recommended ?? []);
+    const catalogItemCount = selectedIds !== void 0 ? selectedIds.length : installableRecommended.length;
+    if (catalogItemCount > 0) {
+      const hasItems = await cacheHasItems();
+      if (!hasItems && !options.allowEmptyCache) {
+        const message = "No catalog content found. Run `haus update` first.";
+        if (isDryRun) {
+          warn(`Catalog cache is empty \u2014 dry-run will skip catalog items. ${message}`);
+        } else {
+          error(message);
+          process.exitCode = 1;
+          return;
+        }
+      } else if (hasItems) {
+        const cacheAgeMs = await getCacheManifestAge();
+        if (cacheAgeMs !== null) {
+          const cacheAgeDays = Math.floor(cacheAgeMs / (1e3 * 60 * 60 * 24));
+          if (cacheAgeDays >= STALE_CACHE_THRESHOLD_DAYS) {
+            warn(
+              `Catalog cache is ${cacheAgeDays} days old \u2014 run \`haus update\` for the latest content.`
+            );
+          }
+        }
+      }
+    }
+  }
+  const files = await writeClaudeFiles(root, isDryRun, selectedIds, {
+    refillConfig: options.refillConfig,
+    force: options.force,
+    prune: options.prune
+  });
+  if (!isDryRun) {
+    try {
+      const cacheDir = hausPath(root, "llms-cache");
+      const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
+      const installedIds = new Set(lock.map((entry) => entry.id));
+      const allItems = await loadCatalog(root);
+      const installedItems = allItems.filter((item) => installedIds.has(item.id));
+      const summary = await fetchRefsForItems(installedItems, cacheDir);
+      if (summary.fetched > 0)
+        log(`Fetched ${summary.fetched} llms.txt reference(s) to ${cacheDir}`);
+      if (summary.failed > 0)
+        warn(
+          `Failed to fetch ${summary.failed} llms.txt reference(s): ${summary.failedUrls.join(", ")}`
+        );
+      const pruned = await pruneOrphanedRefs(cacheDir, new Set(collectLlmsTxtUrls(installedItems)));
+      if (pruned > 0)
+        log(
+          `Removed ${pruned} orphaned llms.txt cache entr${pruned === 1 ? "y" : "ies"} from ${cacheDir}`
+        );
+    } catch (err) {
+      warn(
+        `Could not fetch llms.txt references: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (isDryRun) {
+    log(`Dry-run complete \u2014 ${files.length} file(s) planned, none written. Run --write to apply.`);
+  } else {
+    log("Applied files:");
+    files.forEach((f) => log(`- ${displayPath(root, f)}`));
+  }
+}
+
+// src/commands/backups.ts
+import path23 from "node:path";
+import fs21 from "fs-extra";
+
+// src/utils/prompts.ts
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+async function ask(question) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await rl.question(`${question}
+> `);
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question) {
+  const answer = (await ask(`${question} [y/N]`)).toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+// src/commands/backups.ts
+var LOCK_BACKUP_RE = /^haus\.lock\.\d+\.json$/;
+function classify(name) {
+  if (LOCK_BACKUP_RE.test(name)) return "lock";
+  if (name.startsWith("undo-")) return "undo";
+  if (name.startsWith("prune-")) return "prune";
+  return void 0;
+}
+async function listBackups(root) {
+  const dir = hausPath(root, "backups");
+  if (!await fs21.pathExists(dir)) return [];
+  const names = await fs21.readdir(dir);
+  const entries = [];
+  for (const name of names) {
+    const kind = classify(name);
+    if (!kind) continue;
+    const absPath = path23.join(dir, name);
+    const stat = await fs21.lstat(absPath);
+    if (stat.isSymbolicLink()) continue;
+    const expectDirectory = kind !== "lock";
+    if (stat.isDirectory() !== expectDirectory) continue;
+    entries.push({ id: name, kind, absPath, mtimeMs: stat.mtimeMs });
+  }
+  entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+  return entries;
+}
+function formatAge(mtimeMs, now) {
+  const minutes = Math.round(Math.max(0, now - mtimeMs) / 6e4);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.round(hours / 24)}d ago`;
+}
+async function runList(root) {
+  const entries = await listBackups(root);
+  if (entries.length === 0) {
+    log("No backups found under .haus-workflow/backups/.");
+    return;
+  }
+  const now = Date.now();
+  const newestFirst = [...entries].reverse();
+  for (const entry of newestFirst) {
+    log(`${entry.id}  [${entry.kind}]  ${formatAge(entry.mtimeMs, now)}`);
+  }
+}
+async function isUnsafeWriteTarget(root, target) {
+  const segments = path23.relative(root, target).split(path23.sep).filter(Boolean);
+  let current = root;
+  for (let i = 0; i < segments.length; i++) {
+    current = path23.join(current, segments[i]);
+    const isLastSegment = i === segments.length - 1;
+    try {
+      const stat = await fs21.lstat(current);
+      if (isLastSegment) {
+        if (!stat.isFile()) return true;
+      } else if (!stat.isDirectory()) {
+        return true;
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    }
+  }
+  return false;
+}
+async function lstatIfRegularFile(abs) {
+  try {
+    const stat = await fs21.lstat(abs);
+    return stat.isFile() ? stat : null;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function restoreLockBackup(root, entry, yes) {
+  const target = hausPath(root, "haus.lock.json");
+  if (await isUnsafeWriteTarget(root, target)) {
+    error(
+      `Refusing to restore: ${target} (or a parent directory) is a symlink or other non-regular file \u2014 never written through.`
+    );
+    return false;
+  }
+  if (await fs21.pathExists(target)) {
+    const targetStat = await fs21.stat(target);
+    if (targetStat.mtimeMs > entry.mtimeMs) {
+      warn(
+        `Current haus.lock.json (${new Date(targetStat.mtimeMs).toISOString()}) is newer than backup ${entry.id} (${new Date(entry.mtimeMs).toISOString()}) \u2014 it will be overwritten.`
+      );
+    }
+  }
+  if (!yes) {
+    const ok = await confirm(
+      `Restore .haus-workflow/haus.lock.json from backup ${entry.id}? This overwrites the current lockfile.`
+    );
+    if (!ok) {
+      log("Cancelled.");
+      return false;
+    }
+  }
+  if (!await lstatIfRegularFile(entry.absPath) || await isUnsafeWriteTarget(root, target)) {
+    error(`Refusing to restore: ${entry.id} or ${target} changed since being checked.`);
+    return false;
+  }
+  await fs21.copy(entry.absPath, target, { overwrite: true });
+  log(`Restored .haus-workflow/haus.lock.json from ${entry.id}.`);
+  return true;
+}
+async function collectFilesRecursive(dir) {
+  const files = [];
+  const skippedLinks = [];
+  const skippedOther = [];
+  const names = await fs21.readdir(dir);
+  for (const name of names) {
+    const abs = path23.join(dir, name);
+    const stat = await fs21.lstat(abs);
+    if (stat.isSymbolicLink()) {
+      skippedLinks.push(abs);
+      continue;
+    }
+    if (stat.isDirectory()) {
+      const nested = await collectFilesRecursive(abs);
+      files.push(...nested.files);
+      skippedLinks.push(...nested.skippedLinks);
+      skippedOther.push(...nested.skippedOther);
+    } else if (stat.isFile()) {
+      files.push(abs);
+    } else {
+      skippedOther.push(abs);
+    }
+  }
+  return { files, skippedLinks, skippedOther };
+}
+async function restoreDirBackup(root, entry, yes) {
+  const { files, skippedLinks, skippedOther } = await collectFilesRecursive(entry.absPath);
+  if (skippedLinks.length > 0) {
+    warn(
+      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path23.relative(entry.absPath, abs)).join(", ")}`
+    );
+  }
+  if (skippedOther.length > 0) {
+    warn(
+      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path23.relative(entry.absPath, abs)).join(", ")}`
+    );
+  }
+  if (files.length === 0) {
+    log(`Backup ${entry.id} contains no files.`);
+    return false;
+  }
+  const safeFiles = [];
+  const unsafeTargets = [];
+  for (const abs of files) {
+    const rel = path23.relative(entry.absPath, abs);
+    const target = path23.join(root, rel);
+    if (await isUnsafeWriteTarget(root, target)) unsafeTargets.push(rel);
+    else safeFiles.push(abs);
+  }
+  if (unsafeTargets.length > 0) {
+    warn(
+      `Skipped ${unsafeTargets.length} restore target(s) that are a symlink (or under one) rather than a plain path \u2014 never written through: ${unsafeTargets.join(", ")}`
+    );
+  }
+  if (safeFiles.length === 0) {
+    log(`Backup ${entry.id} has no restorable targets.`);
+    return false;
+  }
+  const stale = [];
+  const vanished = [];
+  const toRestore = [];
+  for (const abs of safeFiles) {
+    const rel = path23.relative(entry.absPath, abs);
+    const backupFileStat = await lstatIfRegularFile(abs);
+    if (!backupFileStat) {
+      vanished.push(rel);
+      continue;
+    }
+    toRestore.push(abs);
+    const target = path23.join(root, rel);
+    if (await fs21.pathExists(target)) {
+      const targetStat = await fs21.stat(target);
+      if (targetStat.mtimeMs > backupFileStat.mtimeMs) {
+        stale.push({
+          rel,
+          targetMtimeMs: targetStat.mtimeMs,
+          backupMtimeMs: backupFileStat.mtimeMs
+        });
+      }
+    }
+  }
+  if (vanished.length > 0) {
+    warn(
+      `Skipped ${vanished.length} backup file(s) that changed (no longer a plain file) since being listed: ${vanished.join(", ")}`
+    );
+  }
+  if (toRestore.length === 0) {
+    log(`Backup ${entry.id} has no restorable files left after re-validation.`);
+    return false;
+  }
+  if (stale.length > 0) {
+    const detail = stale.map(
+      (s) => `${s.rel} (destination: ${new Date(s.targetMtimeMs).toISOString()}, backup: ${new Date(s.backupMtimeMs).toISOString()})`
+    ).join("; ");
+    warn(
+      `${stale.length} file(s) at the restore destination are newer than backup ${entry.id} and will be overwritten: ${detail}`
+    );
+  }
+  if (!yes) {
+    const ok = await confirm(
+      `Restore ${toRestore.length} file(s) from backup ${entry.id} to their original paths?`
+    );
+    if (!ok) {
+      log("Cancelled.");
+      return false;
+    }
+  }
+  let restoredCount = 0;
+  const skippedAtWrite = [];
+  for (const abs of toRestore) {
+    const rel = path23.relative(entry.absPath, abs);
+    const target = path23.join(root, rel);
+    if (!await lstatIfRegularFile(abs) || await isUnsafeWriteTarget(root, target)) {
+      skippedAtWrite.push(rel);
+      continue;
+    }
+    await fs21.ensureDir(path23.dirname(target));
+    await fs21.copy(abs, target, { overwrite: true });
+    restoredCount++;
+  }
+  if (skippedAtWrite.length > 0) {
+    warn(
+      `Skipped ${skippedAtWrite.length} file(s) that changed since being checked, right before restoring: ${skippedAtWrite.join(", ")}`
+    );
+  }
+  log(`Restored ${restoredCount} file(s) from ${entry.id}.`);
+  return restoredCount > 0;
+}
+async function runRestore(root, id, yes) {
+  const entries = await listBackups(root);
+  const entry = entries.find((e) => e.id === id);
+  if (!entry) {
+    error(`No backup found with id "${id}". Run \`haus backups list\` to see available backups.`);
+    return false;
+  }
+  return entry.kind === "lock" ? restoreLockBackup(root, entry, yes) : restoreDirBackup(root, entry, yes);
+}
+async function runPrune(root, opts) {
+  if (opts.olderThanDays === void 0 && opts.keep === void 0) {
+    error("Specify --older-than <days> or --keep <n> \u2014 refusing to prune with no bound.");
+    return false;
+  }
+  const entries = await listBackups(root);
+  const now = Date.now();
+  const toRemove = /* @__PURE__ */ new Set();
+  if (opts.olderThanDays !== void 0) {
+    const cutoff = now - opts.olderThanDays * 24 * 60 * 60 * 1e3;
+    for (const entry of entries) if (entry.mtimeMs < cutoff) toRemove.add(entry.id);
+  }
+  if (opts.keep !== void 0) {
+    const excess = entries.length - opts.keep;
+    if (excess > 0) for (const entry of entries.slice(0, excess)) toRemove.add(entry.id);
+  }
+  if (toRemove.size === 0) {
+    log("Nothing to prune.");
+    return true;
+  }
+  const removeList = entries.filter((e) => toRemove.has(e.id));
+  const keepCount = entries.length - removeList.length;
+  if (!opts.yes) {
+    const ok = await confirm(
+      `Remove ${removeList.length} backup(s)?
+  ${removeList.map((e) => e.id).join("\n  ")}
+Keeping ${keepCount}.`
+    );
+    if (!ok) {
+      log("Cancelled.");
+      return false;
     }
   }
-  const files = await writeClaudeFiles(root, isDryRun, selectedIds, {
-    refillConfig: options.refillConfig,
-    force: options.force
-  });
-  if (!isDryRun) {
+  const removed = [];
+  const failed = [];
+  for (const entry of removeList) {
     try {
-      const cacheDir = hausPath(root, "llms-cache");
-      const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
-      const installedIds = new Set(lock.map((entry) => entry.id));
-      const allItems = await loadCatalog(root);
-      const installedItems = allItems.filter((item) => installedIds.has(item.id));
-      const summary = await fetchRefsForItems(installedItems, cacheDir);
-      if (summary.fetched > 0)
-        log(`Fetched ${summary.fetched} llms.txt reference(s) to ${cacheDir}`);
-      if (summary.failed > 0)
-        warn(
-          `Failed to fetch ${summary.failed} llms.txt reference(s): ${summary.failedUrls.join(", ")}`
-        );
-      const pruned = await pruneOrphanedRefs(cacheDir, new Set(collectLlmsTxtUrls(installedItems)));
-      if (pruned > 0)
-        log(
-          `Removed ${pruned} orphaned llms.txt cache entr${pruned === 1 ? "y" : "ies"} from ${cacheDir}`
-        );
+      await fs21.remove(entry.absPath);
+      removed.push(entry.id);
     } catch (err) {
-      warn(
-        `Could not fetch llms.txt references: ${err instanceof Error ? err.message : String(err)}`
+      failed.push({ id: entry.id, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  log(`Removed ${removed.length} backup(s), kept ${entries.length - removed.length}.`);
+  if (failed.length > 0) {
+    warn(
+      `Failed to remove ${failed.length} backup(s): ${failed.map((f) => `${f.id} (${f.message})`).join(", ")}`
+    );
+    return false;
+  }
+  return true;
+}
+async function runBackups(action, opts = {}) {
+  const root = opts.root ?? process.cwd();
+  if (action === "list") {
+    await runList(root);
+    return;
+  }
+  if (action === "restore") {
+    if (!opts.id) {
+      error("Usage: haus backups restore <id>");
+      process.exitCode = 1;
+      return;
+    }
+    if (!await runRestore(root, opts.id, Boolean(opts.yes))) process.exitCode = 1;
+    return;
+  }
+  let olderThanDays;
+  if (opts.olderThan !== void 0) {
+    const n = Number(opts.olderThan);
+    if (!Number.isFinite(n) || n < 0) {
+      error(
+        `Invalid --older-than value "${opts.olderThan}" \u2014 expected a non-negative number of days.`
       );
+      process.exitCode = 1;
+      return;
     }
+    olderThanDays = n;
   }
-  if (isDryRun) {
-    log(`Dry-run complete \u2014 ${files.length} file(s) planned, none written. Run --write to apply.`);
-  } else {
-    log("Applied files:");
-    files.forEach((f) => log(`- ${displayPath(root, f)}`));
+  let keep;
+  if (opts.keep !== void 0) {
+    const n = Number(opts.keep);
+    if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) {
+      error(`Invalid --keep value "${opts.keep}" \u2014 expected a non-negative integer.`);
+      process.exitCode = 1;
+      return;
+    }
+    keep = n;
   }
+  if (!await runPrune(root, { olderThanDays, keep, yes: Boolean(opts.yes) })) process.exitCode = 1;
 }
 
 // src/commands/catalog-audit.ts
@@ -3024,7 +3699,7 @@ async function runCatalogAudit() {
 // src/commands/clone.ts
 init_exec();
 import { existsSync as existsSync2 } from "node:fs";
-import path18 from "node:path";
+import path24 from "node:path";
 var GIT_LOCATION_VARS = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -3044,15 +3719,50 @@ function repoNameFromUrl(url) {
   const tail = trimmed.split(/[/:]/).pop() ?? "";
   return tail || "repo";
 }
+function normalizeGitUrl(url) {
+  let s = url.trim();
+  s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+  s = s.replace(/^[^/@]+@/, "");
+  s = s.replace(/:(?=[^/])/, "/");
+  s = s.replace(/\/+$/, "");
+  s = s.replace(/\.git$/i, "");
+  return s.toLowerCase();
+}
+async function checkExistingTarget(target, url) {
+  const isRepo = await runGit(["-C", target, "rev-parse", "--is-inside-work-tree"], {
+    env: cloneEnv(),
+    extendEnv: false
+  });
+  if (isRepo.exitCode !== 0) return { kind: "not-a-repo" };
+  const origin = await runGit(["-C", target, "remote", "get-url", "origin"], {
+    env: cloneEnv(),
+    extendEnv: false
+  });
+  if (origin.exitCode !== 0) return { kind: "different-repo", origin: null };
+  const originUrl = origin.stdout.trim();
+  if (normalizeGitUrl(originUrl) === normalizeGitUrl(url)) return { kind: "matches" };
+  return { kind: "different-repo", origin: originUrl };
+}
 async function runClone(url, opts = {}) {
   if (!url || !url.trim()) {
     error("A git URL is required: `haus clone <url> [dir]`.");
     process.exitCode = 1;
     return;
   }
-  const target = path18.resolve(opts.dir?.trim() || repoNameFromUrl(url));
+  const target = path24.resolve(opts.dir?.trim() || repoNameFromUrl(url));
   if (existsSync2(target)) {
-    log(`\u2022 ${path18.basename(target)} already present at ${target} \u2014 skipped`);
+    const check = await checkExistingTarget(target, url);
+    if (check.kind === "matches") {
+      log(`\u2022 ${path24.basename(target)} already cloned here, matches ${url} \u2014 skipped`);
+      return;
+    }
+    const message = check.kind === "not-a-repo" ? `${target} already exists and is not a git repository \u2014 refusing to clone ${url} there. Remove or rename it, or pass a different [dir].` : `${target} already exists as a different repository (origin: ${check.origin ?? "(no origin remote)"}) \u2014 refusing to clone ${url} there. Remove or rename it, or pass a different [dir].`;
+    if (opts.dryRun) {
+      warn(`[dry-run] ${message}`);
+      return;
+    }
+    error(message);
+    process.exitCode = 1;
     return;
   }
   if (opts.dryRun) {
@@ -3123,8 +3833,8 @@ async function resolveBaseRef(root) {
 }
 
 // src/decisions/check.ts
-import path21 from "node:path";
-import fs19 from "fs-extra";
+import path27 from "node:path";
+import fs24 from "fs-extra";
 
 // src/decisions/diff.ts
 init_exec();
@@ -3179,22 +3889,22 @@ function matchesAnyRegex(filePath, patterns) {
 }
 
 // src/decisions/paths.ts
-import path19 from "node:path";
-import fs17 from "fs-extra";
+import path25 from "node:path";
+import fs22 from "fs-extra";
 async function resolveDecisionsDir(root) {
-  const primary = path19.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  if (await fs17.pathExists(primary)) return primary;
-  const legacy = path19.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  if (await fs17.pathExists(legacy)) return legacy;
+  const primary = path25.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  if (await fs22.pathExists(primary)) return primary;
+  const legacy = path25.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  if (await fs22.pathExists(legacy)) return legacy;
   return primary;
 }
 function relativeDecisionPath(decisionsDir, root) {
-  return path19.relative(root, decisionsDir).replace(/\\/g, "/");
+  return path25.relative(root, decisionsDir).replace(/\\/g, "/");
 }
 
 // src/decisions/validate.ts
-import path20 from "node:path";
-import fs18 from "fs-extra";
+import path26 from "node:path";
+import fs23 from "fs-extra";
 function validateDecisionContent(content2) {
   const errors = [];
   for (const section of DECISIONS_TRIGGERS.requiredSections) {
@@ -3223,14 +3933,14 @@ function decisionNumberFromFile(name) {
   return match?.[1] ?? null;
 }
 async function validateIndexSync(decisionsDir, decisionFiles) {
-  const readmePath = path20.join(decisionsDir, "README.md");
-  if (!await fs18.pathExists(readmePath)) {
+  const readmePath = path26.join(decisionsDir, "README.md");
+  if (!await fs23.pathExists(readmePath)) {
     return ["docs/decisions/README.md is missing"];
   }
   const readme = await readText(readmePath) ?? "";
   const errors = [];
   for (const file of decisionFiles) {
-    const num = decisionNumberFromFile(path20.basename(file));
+    const num = decisionNumberFromFile(path26.basename(file));
     if (num && !indexReferencesNumber(readme, num)) {
       errors.push(`README.md missing index row for ADR-${num}`);
     }
@@ -3284,22 +3994,22 @@ async function checkSatisfaction(input2) {
   const errors = [];
   const decisionsPrefix = `${input2.decisionsRel}/`;
   const newDecisionFiles = input2.changedFiles.filter(
-    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path21.basename(f))
+    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path27.basename(f))
   );
   if (newDecisionFiles.length === 0) {
     errors.push(`no new or updated decision under ${input2.decisionsRel}/`);
     return errors;
   }
-  const decisionsDir = path21.join(input2.root, input2.decisionsRel);
+  const decisionsDir = path27.join(input2.root, input2.decisionsRel);
   for (const rel of newDecisionFiles) {
-    const abs = path21.join(input2.root, rel);
+    const abs = path27.join(input2.root, rel);
     const content2 = await readText(abs) ?? "";
     const valid = validateDecisionContent(content2);
     if (!valid.ok) errors.push(...valid.errors.map((e) => `${rel}: ${e}`));
   }
   const indexErrors = await validateIndexSync(
     decisionsDir,
-    newDecisionFiles.map((f) => path21.basename(f))
+    newDecisionFiles.map((f) => path27.basename(f))
   );
   errors.push(...indexErrors);
   return errors;
@@ -3343,8 +4053,8 @@ ${opts.commitMessages ?? ""}`;
     changedFiles: stats.files
   });
   if (satisfactionErrors.length > 0 && decisionsRel !== legacyRel) {
-    const legacyExists = await fs19.pathExists(path21.join(root, legacyRel));
-    if (legacyExists && !await fs19.pathExists(decisionsDir)) {
+    const legacyExists = await fs24.pathExists(path27.join(root, legacyRel));
+    if (legacyExists && !await fs24.pathExists(decisionsDir)) {
       satisfactionErrors = await checkSatisfaction({
         root,
         decisionsRel: legacyRel,
@@ -3364,8 +4074,8 @@ ${opts.commitMessages ?? ""}`;
   return { triggered: true, satisfied: false, reasons, securityTriggered };
 }
 async function listDecisionNumbers(decisionsDir) {
-  if (!await fs19.pathExists(decisionsDir)) return [];
-  const entries = await fs19.readdir(decisionsDir);
+  if (!await fs24.pathExists(decisionsDir)) return [];
+  const entries = await fs24.readdir(decisionsDir);
   return entries.map((name) => decisionNumberFromFile(name)).filter((n) => n != null).map((n) => Number(n));
 }
 
@@ -3407,7 +4117,7 @@ async function runDecisionsGuard(options = {}) {
 }
 
 // src/commands/decisions.ts
-import path22 from "node:path";
+import path28 from "node:path";
 
 // src/decisions/next-number.ts
 async function nextDecisionNumber(root) {
@@ -3518,7 +4228,7 @@ async function runDecisions(sub, arg, options = {}) {
     return;
   }
   if (sub === "validate") {
-    const target = arg ? path22.resolve(root, arg) : void 0;
+    const target = arg ? path28.resolve(root, arg) : void 0;
     if (!target) {
       error("usage: haus decisions validate <path-to-decision.md>");
       process.exitCode = 1;
@@ -3535,18 +4245,18 @@ async function runDecisions(sub, arg, options = {}) {
 }
 
 // src/commands/doctor.ts
-import path28 from "node:path";
-import fs22 from "fs-extra";
+import path35 from "node:path";
+import fs28 from "fs-extra";
 
 // src/decisions/doctor.ts
-import path23 from "node:path";
-import fs20 from "fs-extra";
+import path29 from "node:path";
+import fs25 from "fs-extra";
 async function auditDecisionsLayout(root) {
   const findings = [];
-  const primary = path23.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const legacy = path23.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  const hasPrimary = await fs20.pathExists(primary);
-  const hasLegacy = await fs20.pathExists(legacy);
+  const primary = path29.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const legacy = path29.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  const hasPrimary = await fs25.pathExists(primary);
+  const hasLegacy = await fs25.pathExists(legacy);
   if (!hasPrimary && hasLegacy) {
     findings.push({
       level: "advisory",
@@ -3559,8 +4269,8 @@ async function auditDecisionsLayout(root) {
   if (!hasPrimary) return findings;
   const decisionsDir = await resolveDecisionsDir(root);
   const rel = relativeDecisionPath(decisionsDir, root);
-  const readmePath = path23.join(decisionsDir, "README.md");
-  if (!await fs20.pathExists(readmePath)) {
+  const readmePath = path29.join(decisionsDir, "README.md");
+  if (!await fs25.pathExists(readmePath)) {
     findings.push({
       level: "advisory",
       line: `- DECISIONS: missing ${rel}/README.md index`,
@@ -3570,7 +4280,7 @@ async function auditDecisionsLayout(root) {
     return findings;
   }
   const readme = await readText(readmePath);
-  const entries = (await fs20.readdir(decisionsDir)).filter(
+  const entries = (await fs25.readdir(decisionsDir)).filter(
     (f) => f.endsWith(".md") && f !== "README.md"
   );
   for (const file of entries) {
@@ -3584,7 +4294,7 @@ async function auditDecisionsLayout(root) {
       });
     }
   }
-  const claude = await readText(path23.join(root, "CLAUDE.md"));
+  const claude = await readText(path29.join(root, "CLAUDE.md"));
   if (claude && !claude.includes(`@${rel}/README.md`)) {
     findings.push({
       level: "advisory",
@@ -3614,8 +4324,12 @@ async function auditDecisionsLayout(root) {
   return findings;
 }
 
+// src/scanner/read-context.ts
+import path34 from "node:path";
+import fs27 from "fs-extra";
+
 // src/scanner/scan-project.ts
-import path27 from "node:path";
+import path33 from "node:path";
 
 // src/utils/versions.ts
 import semver from "semver";
@@ -3637,8 +4351,8 @@ function compareVersions(a, b) {
 }
 
 // src/scanner/detect-package-manager.ts
-import path24 from "node:path";
-import fs21 from "fs-extra";
+import path30 from "node:path";
+import fs26 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -3656,9 +4370,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs21.existsSync(path24.join(root, "yarn.lock"))) return "yarn";
-  if (fs21.existsSync(path24.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs21.existsSync(path24.join(root, "package-lock.json"))) return "npm";
+  if (fs26.existsSync(path30.join(root, "yarn.lock"))) return "yarn";
+  if (fs26.existsSync(path30.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs26.existsSync(path30.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
@@ -3860,7 +4574,7 @@ function runDetection(ctx, rules = STACK_RULES) {
 }
 
 // src/scanner/detection.ts
-import path25 from "node:path";
+import path31 from "node:path";
 var UNSUPPORTED_MARKERS = {
   "requirements.txt": "python",
   "pyproject.toml": "python",
@@ -3914,14 +4628,14 @@ function finalizeRoles(registryRoles, deps, files) {
 function collectUnsupportedSignals(files) {
   return [
     ...new Set(
-      files.map((f) => UNSUPPORTED_MARKERS[path25.basename(f)]).filter((s) => Boolean(s))
+      files.map((f) => UNSUPPORTED_MARKERS[path31.basename(f)]).filter((s) => Boolean(s))
     )
   ].sort();
 }
 
 // src/scanner/render.ts
 import { readFile } from "node:fs/promises";
-import path26 from "node:path";
+import path32 from "node:path";
 async function buildContentBlob(root, files) {
   const candidates = files.filter(
     (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".php") || f.endsWith(".json") || f.endsWith(".yml") || f.endsWith(".yaml")
@@ -3929,7 +4643,7 @@ async function buildContentBlob(root, files) {
   const slice = candidates.slice(0, 300);
   const parts = await mapWithConcurrency(slice, async (rel) => {
     try {
-      return await readFile(path26.join(root, rel), "utf8");
+      return await readFile(path32.join(root, rel), "utf8");
     } catch {
       return "";
     }
@@ -4016,8 +4730,8 @@ var SAFE_FILES = [
   "Gemfile"
 ];
 async function scanProject(root) {
-  const pkg = await readJson(path27.join(root, "package.json"));
-  const composer = await readJson(path27.join(root, "composer.json"));
+  const pkg = await readJson(path33.join(root, "package.json"));
+  const composer = await readJson(path33.join(root, "composer.json"));
   const files = await listFiles(root, SAFE_FILES);
   const safeFiles = files.filter((f) => !blocked(f));
   const deps = dependencySet(pkg, composer);
@@ -4044,7 +4758,7 @@ async function scanProject(root) {
   const context = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     root,
-    repoName: String(pkg?.name ?? path27.basename(root)),
+    repoName: String(pkg?.name ?? path33.basename(root)),
     packageManager,
     repoRoles: roles,
     detectedStacks: stacks,
@@ -4061,9 +4775,16 @@ async function scanProject(root) {
 }
 
 // src/scanner/read-context.ts
+async function isCacheFresh(root, cachePath) {
+  const pkgJsonPath = path34.join(root, "package.json");
+  if (!await fs27.pathExists(pkgJsonPath)) return true;
+  const [cacheStat, pkgStat] = await Promise.all([fs27.stat(cachePath), fs27.stat(pkgJsonPath)]);
+  return cacheStat.mtimeMs >= pkgStat.mtimeMs;
+}
 async function readContextOrScan(root) {
-  const context = await readJson(hausPath(root, "context-map.json"));
-  if (context) return context;
+  const cachePath = hausPath(root, "context-map.json");
+  const context = await readJson(cachePath);
+  if (context && await isCacheFresh(root, cachePath)) return context;
   const scan = await scanProject(root);
   return scan;
 }
@@ -4156,7 +4877,7 @@ async function runDoctor(options) {
   } else {
     ok(`- HOOKS OK: ${hooks.message}`);
   }
-  const rootClaudeMdPath = path28.join(root, "CLAUDE.md");
+  const rootClaudeMdPath = path35.join(root, "CLAUDE.md");
   const rootClaudeMdContent = await readText(rootClaudeMdPath);
   if (!rootClaudeMdContent) {
     flag(
@@ -4184,7 +4905,7 @@ async function runDoctor(options) {
       const block = rootClaudeMdContent.slice(beginIdx, endIdx + BLOCK_END.length);
       const importTargets = [...block.matchAll(/@\.haus-workflow\/(\S+)/g)].map((m) => m[1]);
       for (const target of importTargets) {
-        if (!await fs22.pathExists(hausPath(root, target))) {
+        if (!await fs28.pathExists(hausPath(root, target))) {
           flag(
             `- CLAUDE.md import: @.haus-workflow/${target} does not resolve (run \`haus apply --write\`)`,
             `A file CLAUDE.md links to (${target}) is missing, so part of the guidance won't load`,
@@ -4195,7 +4916,7 @@ async function runDoctor(options) {
     }
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs22.pathExists(workflowPath);
+  const workflowExists = await fs28.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -4210,43 +4931,36 @@ async function runDoctor(options) {
     } else {
       const storedHashMatch = firstLine.match(/hash=(sha256-[a-f0-9]+)/);
       const bodyContent = workflowContent.slice(firstLine.length + 1);
-      const onDiskBodyHash = hashText(normaliseLF(bodyContent));
-      if (storedHashMatch && onDiskBodyHash !== storedHashMatch[1]) {
+      const cachePath = path35.join(getCacheDir(), "templates/agentic-workflow-standard.md");
+      const bundledPath = path35.join(
+        packageRoot(),
+        "library",
+        "global",
+        "templates",
+        "agentic-workflow-standard.md"
+      );
+      const templatePath = await fs28.pathExists(cachePath) ? cachePath : bundledPath;
+      const templateContent = await readText(templatePath);
+      const verdict = checkManagedTamper(bodyContent, storedHashMatch?.[1], templateContent ?? null);
+      if (verdict.status === "tampered" || verdict.status === "legacy-diverged") {
         flag(
           "- .haus-workflow/WORKFLOW.md: modified locally (run `haus apply --write --force` to restore)",
           "The workflow standard file was edited after haus wrote it",
           "haus apply --write --force"
         );
-      } else {
-        const cachePath = path28.join(getCacheDir(), "templates/agentic-workflow-standard.md");
-        const bundledPath = path28.join(
-          packageRoot(),
-          "library",
-          "global",
-          "templates",
-          "agentic-workflow-standard.md"
+      } else if (verdict.status === "stale") {
+        suggest(
+          "- .haus-workflow/WORKFLOW.md: stale (template updated \u2014 run `haus apply --write`)",
+          "The workflow standard is out of date",
+          "haus apply --write"
         );
-        const templatePath = await fs22.pathExists(cachePath) ? cachePath : bundledPath;
-        const templateContent = await readText(templatePath);
-        if (storedHashMatch && templateContent) {
-          const currentHash = hashText(normaliseLF(templateContent));
-          if (storedHashMatch[1] !== currentHash) {
-            suggest(
-              "- .haus-workflow/WORKFLOW.md: stale (template updated \u2014 run `haus apply --write`)",
-              "The workflow standard is out of date",
-              "haus apply --write"
-            );
-          } else {
-            ok("- .haus-workflow/WORKFLOW.md: OK");
-          }
-        } else {
-          ok("- .haus-workflow/WORKFLOW.md: OK");
-        }
+      } else {
+        ok("- .haus-workflow/WORKFLOW.md: OK");
       }
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs22.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs28.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -4254,7 +4968,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs22.readFile(workflowConfigPath, "utf8");
+    const cfg = await fs28.readFile(workflowConfigPath, "utf8");
     const unfilled = cfg.split("\n").filter((l) => l.includes("<!-- fill in")).length;
     if (unfilled > 0) {
       suggest(
@@ -4267,15 +4981,17 @@ async function runDoctor(options) {
     }
   }
   if (workflowExists) {
-    const prettierIgnore = await readText(path28.join(root, ".prettierignore")) ?? "";
-    if (!prettierIgnore.split("\n").some((l) => l.trim() === ".haus-workflow/")) {
+    const prettierIgnore = await readText(path35.join(root, ".prettierignore")) ?? "";
+    const lines = prettierIgnore.split("\n");
+    const missing = IGNORED_PATHS.filter((p) => !prettierIgnoreProtects(lines, p));
+    if (missing.length > 0) {
       flag(
-        "- .prettierignore: not protecting .haus-workflow/ (run `haus apply --write`)",
+        `- .prettierignore: not protecting ${missing.join(", ")} (run \`haus apply --write\`)`,
         'The formatter may reformat managed files and trigger false "modified locally" reports',
         "haus apply --write"
       );
     } else {
-      ok("- .prettierignore: protects .haus-workflow/");
+      ok(`- .prettierignore: protects ${IGNORED_PATHS.join(" and ")}`);
     }
   }
   for (const finding of await auditDecisionsLayout(root)) {
@@ -4301,7 +5017,21 @@ async function runDoctor(options) {
       ok(`- CATALOG CACHE: OK (${cacheAgeDays}d old)`);
     }
   }
-  const pkgJson = await readJson(path28.join(packageRoot(), "package.json"));
+  if (recommendation) {
+    const lock = await readJson(hausPath(root, "haus.lock.json"));
+    const recommendedIds = new Set(
+      recommendation.recommended.map((r) => r.id).filter((id) => typeof id === "string")
+    );
+    const orphaned = findOrphanedLockEntries(lock ?? [], recommendedIds).map((entry) => entry.id);
+    if (orphaned.length > 0) {
+      suggest(
+        `- CATALOG ITEMS: ${orphaned.length} installed item(s) no longer in the current recommendation (${orphaned.join(", ")})`,
+        `${orphaned.length} installed item(s) are no longer recommended for this project`,
+        "review whether they are still needed; haus apply --write leaves them in place until removed from the catalog"
+      );
+    }
+  }
+  const pkgJson = await readJson(path35.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -4517,7 +5247,7 @@ function matchesDenyToken(command, denyPhrase) {
   if (denyPhrase === "sudo") {
     return /(?:^|[|;&]\s*)sudo\b/i.test(command);
   }
-  const normalizedCommand = command.toLowerCase().replace(/\s+/g, " ").trim();
+  const normalizedCommand = command.replace(/["'`]/g, "").toLowerCase().replace(/\s+/g, " ").trim();
   return normalizedCommand.includes(denyPhrase.toLowerCase());
 }
 function guardBash(command) {
@@ -4559,41 +5289,29 @@ async function runGuard(kind, _options) {
 }
 
 // src/commands/init.ts
-import path29 from "node:path";
-import fs23 from "fs-extra";
-
-// src/utils/prompts.ts
-import { stdin as input, stdout as output } from "node:process";
-import readline from "node:readline/promises";
-async function ask(question) {
-  const rl = readline.createInterface({ input, output });
-  try {
-    const answer = await rl.question(`${question}
-> `);
-    return answer.trim();
-  } finally {
-    rl.close();
-  }
-}
-async function confirm(question) {
-  const answer = (await ask(`${question} [y/N]`)).toLowerCase();
-  return answer === "y" || answer === "yes";
-}
+import path36 from "node:path";
+import fs29 from "fs-extra";
 
 // src/recommender/git-signal.ts
 init_exec();
-async function readChangedFiles(root) {
-  if (process.env.HAUS_DISABLE_GIT_SIGNALS === "1") return [];
+async function runGitLines(root, args) {
   try {
-    const result = await runGit(["diff", "--name-only"], { cwd: root, timeout: 3e3 });
-    if (result.exitCode !== 0) {
-      return [];
-    }
-    return result.stdout.split("\n").map((x) => x.trim()).filter(Boolean).sort();
+    const result = await runGit(args, { cwd: root, timeout: 3e3 });
+    if (result.exitCode !== 0) return [];
+    return result.stdout.split("\n").map((x) => x.trim()).filter(Boolean);
   } catch {
     return [];
   }
 }
+async function readChangedFiles(root) {
+  if (process.env.HAUS_DISABLE_GIT_SIGNALS === "1") return [];
+  const [unstaged, staged, untracked] = await Promise.all([
+    runGitLines(root, ["diff", "--name-only"]),
+    runGitLines(root, ["diff", "--cached", "--name-only"]),
+    runGitLines(root, ["ls-files", "--others", "--exclude-standard"])
+  ]);
+  return [.../* @__PURE__ */ new Set([...unstaged, ...staged, ...untracked])].sort();
+}
 
 // src/recommender/policies.ts
 var UNSUPPORTED = FORBIDDEN_TAGS;
@@ -4668,6 +5386,7 @@ async function recommend(root, context, opts = {}) {
   const recommended = [];
   const skipped = [];
   const sourceTrust = new Map(sources.items.map((x) => [x.source, x.status]));
+  const formerIds = new Set(items.flatMap((item) => normalizeFormerIds(item.formerIds)));
   const changedFiles = await readChangedFiles(root);
   const skip = (id, code, message, signal) => {
     skipped.push({ id, reason: message, skipReasons: [{ code, message, signal }] });
@@ -4675,6 +5394,10 @@ async function recommend(root, context, opts = {}) {
   const roleSignal = (name) => scannerRoles.has(name.toLowerCase()) ? `role:${name}` : `deep:role:${name}`;
   const stackSignal = (name) => scannerStacks.has(name.toLowerCase()) ? `tag:${name}` : `deep:tag:${name}`;
   for (const item of items) {
+    if (formerIds.has(item.id)) {
+      skip(item.id, "former-id", "Catalog id was renamed and cannot be newly recommended");
+      continue;
+    }
     const normSource = typeof item.source === "string" ? item.source.trim() : "";
     if (!normSource) {
       skip(item.id, "invalid-source", "Item source is missing or empty");
@@ -4916,6 +5639,7 @@ function applyCoInstallSuppression(recommended, skipped) {
   }
 }
 var HARD_SKIP_CODES = /* @__PURE__ */ new Set([
+  "former-id",
   "unsupported-policy",
   "deprecated",
   "curated-not-approved",
@@ -4990,7 +5714,7 @@ function buildOptInEligible(items, skipped) {
   return eligible;
 }
 
-// src/commands/setup-core.ts
+// src/claude/setup-core.ts
 async function runSetupCore(root, opts) {
   const { json, apply, dryRun, quiet, confirm: confirm2 } = opts;
   const say = quiet ? () => {
@@ -5083,8 +5807,8 @@ async function runSetupProject(options) {
 // src/commands/init.ts
 async function runInit(options) {
   const root = process.cwd();
-  const hausDir = path29.join(root, ".haus-workflow");
-  const alreadyInit = await fs23.pathExists(hausDir);
+  const hausDir = path36.join(root, ".haus-workflow");
+  const alreadyInit = await fs29.pathExists(hausDir);
   if (alreadyInit) {
     log("Haus AI already initialized in this project.");
     log("Run `haus setup-project` to reconfigure.");
@@ -5096,8 +5820,8 @@ async function runInit(options) {
 
 // src/install/apply.ts
 import crypto2 from "node:crypto";
-import path30 from "node:path";
-import fs24 from "fs-extra";
+import path37 from "node:path";
+import fs30 from "fs-extra";
 
 // src/install/header.ts
 var MD_PREFIX = "<!-- HAUS-MANAGED";
@@ -5183,57 +5907,57 @@ function hashContent(content2) {
 }
 function sourceVersion() {
   try {
-    const pkgPath = path30.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path37.join(packageRoot(), "package.json");
+    const pkg = JSON.parse(fs30.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
   }
 }
 function globalSrcDir() {
-  return path30.join(packageRoot(), "library", "global");
+  return path37.join(packageRoot(), "library", "global");
 }
 function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
-  const skillDir = path30.join(skillsDir, skillName);
+  const skillDir = path37.join(skillsDir, skillName);
   const entries = [];
-  for (const rel of fs24.readdirSync(skillDir, { recursive: true })) {
+  for (const rel of fs30.readdirSync(skillDir, { recursive: true })) {
     if (rel === "SKILL.md") continue;
-    const abs = path30.join(skillDir, rel);
-    if (!fs24.statSync(abs).isFile()) continue;
-    const posixRel = rel.split(path30.sep).join("/");
+    const abs = path37.join(skillDir, rel);
+    if (!fs30.statSync(abs).isFile()) continue;
+    const posixRel = rel.split(path37.sep).join("/");
     entries.push({
       stableId: `skill.${skillName}.${posixRel.replace(/\//g, ".")}`,
-      srcRelPath: path30.join("library", "global", "skills", skillName, rel),
-      destPath: path30.join(claudeDir, "skills", skillName, rel)
+      srcRelPath: path37.join("library", "global", "skills", skillName, rel),
+      destPath: path37.join(claudeDir, "skills", skillName, rel)
     });
   }
   return entries;
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  const skillsDir = path30.join(srcDir, "skills");
-  if (fs24.pathExistsSync(skillsDir)) {
-    for (const skillName of fs24.readdirSync(skillsDir)) {
-      const skillFile = path30.join(skillsDir, skillName, "SKILL.md");
-      if (fs24.pathExistsSync(skillFile)) {
+  const skillsDir = path37.join(srcDir, "skills");
+  if (fs30.pathExistsSync(skillsDir)) {
+    for (const skillName of fs30.readdirSync(skillsDir)) {
+      const skillFile = path37.join(skillsDir, skillName, "SKILL.md");
+      if (fs30.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path30.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path30.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path37.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path37.join(claudeDir, "skills", skillName, "SKILL.md")
         });
         entries.push(...collectSkillAuxFiles(skillsDir, claudeDir, skillName));
       }
     }
   }
-  const commandsDir = path30.join(srcDir, "commands");
-  if (fs24.pathExistsSync(commandsDir)) {
-    for (const fileName of fs24.readdirSync(commandsDir)) {
+  const commandsDir = path37.join(srcDir, "commands");
+  if (fs30.pathExistsSync(commandsDir)) {
+    for (const fileName of fs30.readdirSync(commandsDir)) {
       if (!fileName.endsWith(".md")) continue;
       const commandName = fileName.slice(0, -".md".length);
       entries.push({
         stableId: `command.${commandName}`,
-        srcRelPath: path30.join("library", "global", "commands", fileName),
-        destPath: path30.join(claudeDir, "commands", fileName)
+        srcRelPath: path37.join("library", "global", "commands", fileName),
+        destPath: path37.join(claudeDir, "commands", fileName)
       });
     }
   }
@@ -5259,7 +5983,7 @@ async function applyInstall(options = {}) {
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path30.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path37.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -5279,7 +6003,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs24.pathExistsSync(entry.destPath);
+    const destExists = fs30.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -5319,7 +6043,7 @@ async function applyInstall(options = {}) {
   }
   let mergedSettings;
   if (!check) {
-    const fragmentPath = path30.join(srcDir, "settings-fragments", "hooks.json");
+    const fragmentPath = path37.join(srcDir, "settings-fragments", "hooks.json");
     const fragments = await loadHooksFragment(fragmentPath);
     const settings = await readSettings();
     const { settings: hookSettings, addedIds } = mergeHooks(settings, fragments);
@@ -5333,13 +6057,13 @@ async function applyInstall(options = {}) {
     const currentDestPaths = new Set(sourceFiles.map((f) => f.destPath));
     for (const entry of existingManifest.files) {
       if (currentDestPaths.has(entry.destPath)) continue;
-      if (!fs24.pathExistsSync(entry.destPath)) continue;
+      if (!fs30.pathExistsSync(entry.destPath)) continue;
       const content2 = await readText(entry.destPath);
       if (!content2) continue;
       const hasHeader = parseMarkdownHeader(content2) !== void 0;
       const currentHash = hashContent(content2);
       if (hasHeader && currentHash === entry.hash) {
-        if (!dryRun) await fs24.remove(entry.destPath);
+        if (!dryRun) await fs30.remove(entry.destPath);
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -5508,8 +6232,8 @@ async function runRefresh() {
 }
 
 // src/install/scaffold.ts
-import path31 from "node:path";
-import fs25 from "fs-extra";
+import path38 from "node:path";
+import fs31 from "fs-extra";
 async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   const scaffolded = [];
   const skipped = [];
@@ -5522,27 +6246,27 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
     skipped.push(name);
     if (outcome === "skipped-exists") skippedExisting.push(name);
   };
-  const realRoot = await fs25.realpath(catalogRoot).catch(() => null);
+  const realRoot = await fs31.realpath(catalogRoot).catch(() => null);
   for (const item of items) {
     if (item.type !== "config") continue;
-    const sourcePath = path31.resolve(catalogRoot, item.path);
-    const rel = path31.relative(catalogRoot, sourcePath);
-    const escapes = rel === "" || path31.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
+    const sourcePath = path38.resolve(catalogRoot, item.path);
+    const rel = path38.relative(catalogRoot, sourcePath);
+    const escapes = rel === "" || path38.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
     if (escapes) {
       warn(`Skipping ${item.id}: path '${item.path}' escapes the catalog root`);
       continue;
     }
-    const realSource = await fs25.realpath(sourcePath).catch(() => null);
+    const realSource = await fs31.realpath(sourcePath).catch(() => null);
     if (!realRoot || !realSource) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
     }
-    const realRel = path31.relative(realRoot, realSource);
-    if (realRel !== "" && (path31.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
+    const realRel = path38.relative(realRoot, realSource);
+    if (realRel !== "" && (path38.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
       warn(`Skipping ${item.id}: path '${item.path}' resolves outside the catalog root`);
       continue;
     }
-    const stat = await fs25.lstat(sourcePath).catch(() => null);
+    const stat = await fs31.lstat(sourcePath).catch(() => null);
     if (!stat) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -5552,14 +6276,14 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       continue;
     }
     if (stat.isFile()) {
-      const filename = path31.basename(sourcePath);
-      const dest = path31.join(projectRoot, filename);
+      const filename = path38.basename(sourcePath);
+      const dest = path38.join(projectRoot, filename);
       record(filename, await scaffoldFile(sourcePath, dest, item.id, projectRoot, opts));
     } else if (stat.isDirectory()) {
-      const entries = await fs25.readdir(sourcePath);
+      const entries = await fs31.readdir(sourcePath);
       for (const entry of entries) {
-        const src = path31.join(sourcePath, entry);
-        const dest = path31.join(projectRoot, entry);
+        const src = path38.join(sourcePath, entry);
+        const dest = path38.join(projectRoot, entry);
         record(entry, await scaffoldFile(src, dest, item.id, projectRoot, opts));
       }
     }
@@ -5567,42 +6291,42 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   return { scaffolded, skipped, skippedExisting };
 }
 async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
-  const destDisplay = path31.relative(projectRoot, dest) || path31.basename(dest);
-  const srcStat = await fs25.lstat(src).catch(() => null);
+  const destDisplay = path38.relative(projectRoot, dest) || path38.basename(dest);
+  const srcStat = await fs31.lstat(src).catch(() => null);
   if (!srcStat) {
-    warn(`Skipping ${path31.basename(src)}: source not found`);
+    warn(`Skipping ${path38.basename(src)}: source not found`);
     return "skipped-refused";
   }
   if (srcStat.isSymbolicLink()) {
-    warn(`Skipping ${path31.basename(src)}: source is a symlink`);
+    warn(`Skipping ${path38.basename(src)}: source is a symlink`);
     return "skipped-refused";
   }
-  const exists = await fs25.pathExists(dest);
+  const exists = await fs31.pathExists(dest);
   if (exists && !opts.force) {
     warn(`Skipping ${destDisplay}: already exists \u2014 re-run with --force to overwrite it`);
     return "skipped-exists";
   }
   if (opts.dryRun) {
-    log(`[dry-run] would ${exists ? "overwrite" : "create"} ${path31.basename(dest)} (${itemId})`);
+    log(`[dry-run] would ${exists ? "overwrite" : "create"} ${path38.basename(dest)} (${itemId})`);
     return "scaffolded";
   }
   if (exists && opts.force) {
-    await fs25.remove(dest);
+    await fs31.remove(dest);
   }
-  await fs25.ensureDir(path31.dirname(dest));
-  await fs25.copy(src, dest, {
+  await fs31.ensureDir(path38.dirname(dest));
+  await fs31.copy(src, dest, {
     overwrite: true,
     dereference: false,
     // A vanished/unreadable entry mid-walk must skip that path, not crash the copy.
     filter: (s) => {
       try {
-        return !fs25.lstatSync(s).isSymbolicLink();
+        return !fs31.lstatSync(s).isSymbolicLink();
       } catch {
         return false;
       }
     }
   });
-  log(`${exists ? "Overwrote" : "Created"} ${path31.basename(dest)} (${itemId})`);
+  log(`${exists ? "Overwrote" : "Created"} ${path38.basename(dest)} (${itemId})`);
   return "scaffolded";
 }
 
@@ -5659,8 +6383,8 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path32 from "node:path";
-import fs26 from "fs-extra";
+import path39 from "node:path";
+import fs32 from "fs-extra";
 
 // src/claude/managed-paths.ts
 var PROJECT_MANAGED_CLAUDE_REL = ["rules/haus.md"];
@@ -5672,67 +6396,85 @@ function coreManagedAbsolutePaths(root) {
 }
 
 // src/commands/undo.ts
-async function collectManagedPaths(root) {
-  const paths = new Set(coreManagedAbsolutePaths(root));
+async function collectCoreManagedPaths(root) {
+  const existing = [];
+  for (const abs of coreManagedAbsolutePaths(root)) {
+    if (await fs32.pathExists(abs)) existing.push(abs);
+  }
+  return existing;
+}
+async function collectLockTrackedPaths(root) {
   const lock = await readJson(hausPath(root, "haus.lock.json"));
+  const removable = [];
+  const preserved = [];
   for (const row of lock ?? []) {
-    for (const rel of row.paths ?? []) {
-      paths.add(path32.resolve(root, rel));
+    const relPaths = row.paths ?? [];
+    const existingRel = [];
+    for (const rel of relPaths) {
+      if (await fs32.pathExists(path39.resolve(root, rel))) existingRel.push(rel);
+    }
+    if (existingRel.length === 0) continue;
+    if (row.hash === void 0) {
+      removable.push(...existingRel.map((rel) => path39.resolve(root, rel)));
+      continue;
+    }
+    const currentHash = await hashInstalledPaths(root, existingRel);
+    if (currentHash === row.hash) {
+      removable.push(...existingRel.map((rel) => path39.resolve(root, rel)));
+    } else {
+      preserved.push(...existingRel.map((rel) => path39.resolve(root, rel)));
+      log(`Preserving locally-modified ${row.id ?? "(unknown item)"}: ${existingRel.join(", ")}`);
     }
   }
-  const existing = [];
-  for (const abs of paths) {
-    if (await fs26.pathExists(abs)) existing.push(abs);
-  }
-  return existing;
+  return { removable, preserved };
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs26.pathExists(settingsPath)) return false;
+  if (!await fs32.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path32.join(root, "CLAUDE.md");
-  if (!await fs26.pathExists(filePath)) return false;
-  const text = await fs26.readFile(filePath, "utf8");
+  const filePath = path39.join(root, "CLAUDE.md");
+  if (!await fs32.pathExists(filePath)) return false;
+  const text = await fs32.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs26.pathExists(settingsPath)) return false;
+  if (!await fs32.pathExists(settingsPath)) return false;
   let settings = await readProjectSettings(root);
   settings = stripHausHooks(stripHausAsk(stripHausAllow(stripHausDeny(settings))));
   const hasContent = Object.keys(settings).length > 0;
   if (hasContent) {
     await writeProjectSettings(root, settings);
-    log(`Stripped haus rules from ${path32.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path39.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs26.remove(settingsPath);
-  log(`Removed ${path32.relative(root, settingsPath)} (no user-owned settings remained).`);
+  await fs32.remove(settingsPath);
+  log(`Removed ${path39.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path32.join(root, "CLAUDE.md");
-  if (!await fs26.pathExists(filePath)) return false;
-  const prev = await fs26.readFile(filePath, "utf8");
+  const filePath = path39.join(root, "CLAUDE.md");
+  if (!await fs32.pathExists(filePath)) return false;
+  const prev = await fs32.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs26.remove(filePath);
+    await fs32.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs26.writeFile(filePath, next, "utf8");
+    await fs32.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs26.pathExists(dir)) return;
+  if (!await fs32.pathExists(dir)) return;
   try {
-    const entries = await fs26.readdir(dir);
-    if (entries.length === 0) await fs26.remove(dir);
+    const entries = await fs32.readdir(dir);
+    if (entries.length === 0) await fs32.remove(dir);
   } catch {
   }
 }
@@ -5741,27 +6483,34 @@ async function backupManagedFilesBeforeUndo(root, managedAbsPaths) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupRoot = hausPath(root, "backups", `undo-${stamp}`);
   for (const abs of managedAbsPaths) {
-    if (!await fs26.pathExists(abs)) continue;
-    const rel = path32.relative(root, abs);
-    const backupPath = path32.join(backupRoot, rel);
-    await fs26.ensureDir(path32.dirname(backupPath));
-    await fs26.copy(abs, backupPath);
+    if (!await fs32.pathExists(abs)) continue;
+    const rel = path39.relative(root, abs);
+    const backupPath = path39.join(backupRoot, rel);
+    await fs32.ensureDir(path39.dirname(backupPath));
+    await fs32.copy(abs, backupPath);
   }
-  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path32.relative(root, backupRoot)}.`);
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path39.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
-  const root = process.cwd();
-  const managed = await collectManagedPaths(root);
+  const root = options.root ?? process.cwd();
+  const coreManaged = await collectCoreManagedPaths(root);
+  const { removable: lockRemovable, preserved: lockPreserved } = await collectLockTrackedPaths(root);
+  const managed = [.../* @__PURE__ */ new Set([...coreManaged, ...lockRemovable])];
   const stripSettings = await settingsHasHausContent(root);
   const stripClaudeMd = await claudeMdHasHausBlock(root);
   if (managed.length === 0 && !stripSettings && !stripClaudeMd) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path32.relative(root, p));
+  const relTargets = managed.map((p) => path39.relative(root, p));
   const summaryParts = [...relTargets];
   if (stripSettings) summaryParts.push(".claude/settings.json (haus rules only)");
   if (stripClaudeMd) summaryParts.push("CLAUDE.md (haus import block only)");
+  if (lockPreserved.length > 0) {
+    summaryParts.push(
+      `(preserving ${lockPreserved.length} locally-modified catalog item file(s) \u2014 not shown above)`
+    );
+  }
   if (!options.yes) {
     const ok = await confirm(
       `Remove haus-managed files?
@@ -5775,9 +6524,9 @@ User-owned .claude/ files will be preserved.`
   }
   await backupManagedFilesBeforeUndo(root, managed);
   for (const abs of managed) {
-    if (!await fs26.pathExists(abs)) continue;
-    await fs26.remove(abs);
-    log(`Removed ${path32.relative(root, abs)}`);
+    if (!await fs32.pathExists(abs)) continue;
+    await fs32.remove(abs);
+    log(`Removed ${path39.relative(root, abs)}`);
   }
   if (stripSettings) await stripProjectSettings(root);
   if (stripClaudeMd) await stripRootClaudeMd(root);
@@ -5788,8 +6537,8 @@ User-owned .claude/ files will be preserved.`
 
 // src/install/uninstall.ts
 import crypto3 from "node:crypto";
-import path33 from "node:path";
-import fs27 from "fs-extra";
+import path40 from "node:path";
+import fs33 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
   const manifest = await readManifest();
@@ -5799,7 +6548,7 @@ async function runUninstall(options = {}) {
     return result;
   }
   for (const entry of manifest.files) {
-    const exists = fs27.pathExistsSync(entry.destPath);
+    const exists = fs33.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -5817,23 +6566,23 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs27.remove(entry.destPath);
-    await pruneEmptyDir(path33.dirname(entry.destPath));
+    await fs33.remove(entry.destPath);
+    await pruneEmptyDir(path40.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
   const settings = await readSettings();
   const stripped = stripHausHooks(stripHausAsk(stripHausAllow(stripHausDeny(settings))));
   await writeSettings(stripped);
   result.hooksStripped = true;
-  const hausDir = path33.join(globalClaudeDir(), "haus");
+  const hausDir = path40.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs27.pathExistsSync(manifestPath2)) {
-    await fs27.remove(manifestPath2);
+  if (fs33.pathExistsSync(manifestPath2)) {
+    await fs33.remove(manifestPath2);
   }
-  if (fs27.pathExistsSync(hausDir)) {
+  if (fs33.pathExistsSync(hausDir)) {
     try {
-      const remaining = await fs27.readdir(hausDir);
-      if (remaining.length === 0) await fs27.remove(hausDir);
+      const remaining = await fs33.readdir(hausDir);
+      if (remaining.length === 0) await fs33.remove(hausDir);
     } catch {
     }
   }
@@ -5866,12 +6615,12 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/update.ts
-import path35 from "node:path";
+import path42 from "node:path";
 
 // src/claude/refresh-project.ts
-import fs28 from "fs-extra";
+import fs34 from "fs-extra";
 async function isHausProject(root) {
-  if (await fs28.pathExists(hausPath(root, "recommendation.json"))) return true;
+  if (await fs34.pathExists(hausPath(root, "recommendation.json"))) return true;
   const result = await readJsonDetailed(claudePath(root, "settings.json"));
   if (result.status === "ok") return result.value._haus != null;
   return false;
@@ -5906,7 +6655,7 @@ function summarizeLockDiff(before, after) {
 
 // src/update/lockfile.ts
 import { mkdir, readFile as readFile2, copyFile } from "node:fs/promises";
-import path34 from "node:path";
+import path41 from "node:path";
 async function readLockSummary(root) {
   const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
   const catalogRef = lock.find((item) => item.catalogRef)?.catalogRef ?? null;
@@ -5917,7 +6666,7 @@ async function checkLock(root) {
   const hasValidVersions = lock.every(
     (item) => !item.version || normalizeVersion(item.version) !== null
   );
-  const catalogRef = lock[0]?.catalogRef ?? null;
+  const catalogRef = lock.find((item) => item.catalogRef)?.catalogRef ?? null;
   const drift = [];
   for (const item of lock) {
     if (!item.hash) continue;
@@ -5942,7 +6691,7 @@ async function applyLock(root) {
   try {
     const backupDir = hausPath(root, "backups");
     await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path34.join(backupDir, `haus.lock.${Date.now()}.json`));
+    await copyFile(lockPath, path41.join(backupDir, `haus.lock.${Date.now()}.json`));
   } catch {
   }
   const enriched = await Promise.all(
@@ -5964,7 +6713,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile2(path34.join(root, ".claude", "settings.json"), "utf8");
+    await readFile2(path41.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -5980,23 +6729,28 @@ async function runUpdate(options) {
     return;
   }
   if (options.check) {
-    const pkgJson2 = await readJson(path35.join(packageRoot(), "package.json"));
+    const pkgJson2 = await readJson(path42.join(packageRoot(), "package.json"));
     const currentVersion2 = pkgJson2?.version ?? "0.0.0";
-    const [status, npmVersion, latestCatalogTag, globalInstallDrift] = await Promise.all([
-      checkLock(root),
+    const [status, npmVersion, latestCatalogTag, globalInstallDrift, catalogItems, lockItems] = await Promise.all([
+      options.fast ? fastLockStatus(root) : checkLock(root),
       fetchNpmVersionStatus(currentVersion2),
       fetchLatestCatalogTag(),
-      detectGlobalInstallDrift()
+      options.fast ? Promise.resolve(null) : detectGlobalInstallDrift(),
+      loadCatalog(root),
+      readJson(hausPath(root, "haus.lock.json"))
     ]);
-    const installedRef = status.catalogRef ?? "main";
-    const catalogRefBehind = latestCatalogTag !== null && installedRef !== latestCatalogTag ? `installed from ${installedRef}, latest tag is ${latestCatalogTag}` : false;
+    const formerIdMigrations = findFormerIdMigrations(lockItems ?? [], catalogItems);
+    const installedRef = options.fast ? status.catalogRef : status.catalogRef ?? "main";
+    const catalogRefBehind = installedRef !== null && latestCatalogTag !== null && installedRef !== latestCatalogTag ? `installed from ${installedRef}, latest tag is ${latestCatalogTag}` : false;
     log(
       JSON.stringify(
         {
           ...status,
+          checkMode: options.fast ? "fast" : "full",
           installedCatalogRef: installedRef,
           latestCatalogTag,
           catalogRefBehind,
+          formerIdMigrations,
           globalInstallDrift,
           localOverrides: await hasLocalOverrides(root),
           summary: diffGeneratedFiles(),
@@ -6006,10 +6760,11 @@ async function runUpdate(options) {
         2
       )
     );
-    if (status.count > 0 && !status.ok) process.exitCode = 1;
+    const hasHashDrift = !options.fast && status.count > 0 && "ok" in status && !status.ok;
+    if (hasHashDrift || formerIdMigrations.length > 0) process.exitCode = 1;
     return;
   }
-  const pkgJson = await readJson(path35.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path42.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -6048,7 +6803,7 @@ async function runFromHookCheck(root) {
   try {
     const summary = await readLockSummary(root);
     if (summary.count === 0) return;
-    const pkgJson = await readJson(path35.join(packageRoot(), "package.json"));
+    const pkgJson = await readJson(path42.join(packageRoot(), "package.json"));
     const currentVersion = pkgJson?.version ?? "0.0.0";
     const [npmVersion, latestCatalogTag] = await Promise.all([
       fetchNpmVersionStatus(currentVersion),
@@ -6114,19 +6869,18 @@ async function detectGlobalInstallDrift() {
     return null;
   }
 }
+async function fastLockStatus(root) {
+  const summary = await readLockSummary(root);
+  return { count: summary.count, catalogRef: summary.catalogRef, drift: [], driftCount: 0 };
+}
 
 // src/commands/validate-catalog.ts
-import path37 from "node:path";
+import path44 from "node:path";
 
 // src/catalog/validate-core.ts
-import fs29 from "node:fs";
-import path36 from "node:path";
+import fs35 from "node:fs";
+import path43 from "node:path";
 var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
-function isSafeCatalogPath2(itemPath) {
-  if (!itemPath || path36.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
-  const normalized = path36.normalize(itemPath);
-  return !normalized.startsWith("..") && !normalized.includes("/..");
-}
 function auditForbiddenStacks(items) {
   const failures = [];
   for (const item of items) {
@@ -6206,7 +6960,7 @@ function auditManifestStructure(manifestVersion, items) {
     if (item.type === "skill" || item.type === "agent" || item.type === "template" || item.type === "command" || item.type === "config") {
       if (!item.path) {
         failures.push(`${item.id}: missing path`);
-      } else if (!isSafeCatalogPath2(item.path)) {
+      } else if (!isSafeCatalogPath(item.path)) {
         failures.push(`${item.id}: path "${item.path}" is not a safe relative path`);
       } else {
         const norm = item.path.replace(/\\/g, "/");
@@ -6235,14 +6989,14 @@ function checkRequiredFrontmatter(text, label) {
 }
 function readForAudit(absPath, label, failures) {
   try {
-    return fs29.readFileSync(absPath, "utf8");
+    return fs35.readFileSync(absPath, "utf8");
   } catch (err) {
     failures.push(`${label}: unreadable (${err instanceof Error ? err.message : String(err)})`);
     return null;
   }
 }
 function auditTemplateContent(manifestDir, absPath, itemId) {
-  const rel = path36.relative(manifestDir, absPath);
+  const rel = path43.relative(manifestDir, absPath);
   const failures = [];
   const text = readForAudit(absPath, `${itemId}: ${rel}`, failures);
   if (text === null) return failures;
@@ -6263,48 +7017,48 @@ function auditTemplateContent(manifestDir, absPath, itemId) {
 function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
-    if (!item.path || !isSafeCatalogPath2(item.path)) continue;
-    const absPath = path36.join(manifestDir, item.path);
+    if (!item.path || !isSafeCatalogPath(item.path)) continue;
+    const absPath = path43.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path36.join(absPath, "SKILL.md");
-      if (!fs29.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path36.relative(manifestDir, skillMd)}`);
+      const skillMd = path43.join(absPath, "SKILL.md");
+      if (!fs35.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path43.relative(manifestDir, skillMd)}`);
         continue;
       }
       const text = readForAudit(skillMd, `${item.id}: SKILL.md`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: SKILL.md`));
       failures.push(
-        ...auditForbiddenTagsInText(text, `${item.id}: ${path36.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path43.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs29.existsSync(absPath)) {
+      if (!fs35.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const rel = path36.relative(manifestDir, absPath);
+      const rel = path43.relative(manifestDir, absPath);
       const text = readForAudit(absPath, `${item.id}: ${rel}`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditForbiddenTagsInText(text, `${item.id}: ${rel}`));
     } else if (item.type === "template") {
-      if (!fs29.existsSync(absPath)) {
+      if (!fs35.existsSync(absPath)) {
         failures.push(`${item.id}: missing template file ${item.path}`);
         continue;
       }
       failures.push(...auditTemplateContent(manifestDir, absPath, item.id));
     } else if (item.type === "command") {
-      if (!fs29.existsSync(absPath)) {
+      if (!fs35.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
-      const rel = path36.relative(manifestDir, absPath);
+      const rel = path43.relative(manifestDir, absPath);
       const text = readForAudit(absPath, `${item.id}: ${rel}`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditTemplateContent(manifestDir, absPath, item.id));
     } else if (item.type === "config") {
-      if (!fs29.existsSync(absPath)) {
+      if (!fs35.existsSync(absPath)) {
         failures.push(`${item.id}: missing config path ${item.path}`);
       }
     }
@@ -6320,7 +7074,7 @@ var DIR_ITEM_TYPE = {
 function walkMd(dir, fn, failures) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir, { withFileTypes: true });
+    entries = fs35.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -6328,7 +7082,7 @@ function walkMd(dir, fn, failures) {
     return;
   }
   for (const entry of entries) {
-    const full = path36.join(dir, entry.name);
+    const full = path43.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn, failures);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -6337,13 +7091,13 @@ function auditMarkdownContent(manifestDir, items) {
   const failures = [];
   const pathSourceMap = buildItemPathSourceMap(items);
   for (const dir of ["skills", "agents", "templates", "commands"]) {
-    const abs = path36.join(manifestDir, dir);
-    if (!fs29.existsSync(abs)) continue;
+    const abs = path43.join(manifestDir, dir);
+    if (!fs35.existsSync(abs)) continue;
     const dirType = DIR_ITEM_TYPE[dir] ?? "";
     walkMd(
       abs,
       (file) => {
-        const rel = path36.relative(manifestDir, file);
+        const rel = path43.relative(manifestDir, file);
         const text = readForAudit(file, rel, failures);
         if (text === null) return;
         const norm = rel.replace(/\\/g, "/");
@@ -6368,6 +7122,7 @@ function auditMarkdownContent(manifestDir, items) {
 function validateCatalogData(manifestDir, manifestVersion, items) {
   const failures = [
     ...auditManifestStructure(manifestVersion, items),
+    ...validateFormerIds(items),
     ...auditOptInMetadata(items),
     ...auditForbiddenStacks(items),
     ...auditShippedFiles(manifestDir, items),
@@ -6384,8 +7139,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path37.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path37.dirname(abs);
+  const abs = path44.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path44.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -6402,8 +7157,8 @@ async function runValidateCatalog(manifestPath2) {
 }
 
 // src/commands/workspace.ts
-import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
-import path44 from "node:path";
+import { existsSync as existsSync6, statSync as statSync3 } from "node:fs";
+import path52 from "node:path";
 
 // src/commands/workspace/aggregate.ts
 async function writeWorkspaceArtifacts(workspaceRoot, repos, relationships = []) {
@@ -6457,7 +7212,7 @@ ${summaries.map(
 }
 
 // src/commands/workspace/config.ts
-import path38 from "node:path";
+import path45 from "node:path";
 import YAML from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
@@ -6480,11 +7235,11 @@ function parseWorkspaceConfig(text) {
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
-  return parseWorkspaceConfig(await readText(path38.join(workspaceRoot, WORKSPACE_FILE)));
+  return parseWorkspaceConfig(await readText(path45.join(workspaceRoot, WORKSPACE_FILE)));
 }
 
 // src/commands/workspace/discover.ts
-import path39 from "node:path";
+import path46 from "node:path";
 import fg4 from "fast-glob";
 import YAML2 from "yaml";
 var DEFAULT_MAX_DEPTH = 3;
@@ -6515,8 +7270,8 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const gitDirs = /* @__PURE__ */ new Set();
   const manifestDirs = /* @__PURE__ */ new Set();
   for (const match of matches) {
-    const base = path39.posix.basename(match);
-    const dir = path39.posix.dirname(match);
+    const base = path46.posix.basename(match);
+    const dir = path46.posix.dirname(match);
     const owner = dir === "." ? "." : dir;
     if (base === ".git") gitDirs.add(owner);
     else manifestDirs.add(owner);
@@ -6532,9 +7287,9 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   }
   repoRoots.sort((a, b) => a.localeCompare(b));
   return mapWithConcurrency(repoRoots, async (relDir) => {
-    const absDir = path39.resolve(workspaceRoot, relDir);
-    const pkg = await readJson(path39.join(absDir, "package.json"));
-    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path39.basename(relDir === "." ? workspaceRoot : absDir);
+    const absDir = path46.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path46.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path46.basename(relDir === "." ? workspaceRoot : absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir);
@@ -6577,7 +7332,7 @@ function renderWorkspaceYaml(config) {
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path39.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path46.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -6614,18 +7369,18 @@ async function runDiscover(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path41 from "node:path";
+import path48 from "node:path";
 
 // src/commands/workspace/manifest.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import path40 from "node:path";
+import path47 from "node:path";
 var MANIFEST_FILE = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(path40.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path47.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -6690,8 +7445,9 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
     return emit({ workspaceRoot, manifest, drift, detail, json: opts.json });
   }
   const manifestByName = new Map(manifest.repos.map((r) => [r.name, r]));
+  const catalogRefByRepo = [];
   for (const repo of config.repos) {
-    const repoRoot = path41.resolve(workspaceRoot, repo.path);
+    const repoRoot = path48.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -6724,6 +7480,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
       });
     }
     const lock = await checkLock(repoRoot);
+    if (lock.catalogRef) catalogRefByRepo.push({ repo: repo.name, ref: lock.catalogRef });
     if (!existsSync3(hausPath(repoRoot, "haus.lock.json"))) {
       flag({
         repo: repo.name,
@@ -6741,6 +7498,14 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
       ok(`- ${repo.name}: OK (${lock.count} lock item(s))`);
     }
   }
+  const distinctRefs = new Set(catalogRefByRepo.map((r) => r.ref));
+  if (distinctRefs.size > 1) {
+    flag({
+      repo: "(workspace)",
+      kind: "catalog-ref-mismatch",
+      detail: `Repos are on different catalog refs \u2014 ${catalogRefByRepo.map((r) => `${r.repo}: ${r.ref}`).join(", ")}. Run \`haus workspace setup --write\` to bring them onto the same ref.`
+    });
+  }
   return emit({ workspaceRoot, manifest, drift, detail, json: opts.json });
 }
 function emit(args) {
@@ -6765,11 +7530,11 @@ function emit(args) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync4, statSync } from "node:fs";
-import path43 from "node:path";
+import path50 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path42 from "node:path";
-import fs30 from "fs-extra";
+import path49 from "node:path";
+import fs36 from "fs-extra";
 function buildWorkspaceImportBlock(client, members) {
   const memberLines = members.map((m) => `- ${m.name} (${m.path})`);
   const body = [
@@ -6787,15 +7552,16 @@ ${BLOCK_END}`;
 async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
   const block = buildWorkspaceImportBlock(opts.client, opts.members);
   const dryRun = opts.dryRun ?? false;
-  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path42.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path49.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
-  const prev = await fs30.pathExists(filePath) ? await fs30.readFile(filePath, "utf8") : "";
+  const existed = await fs36.pathExists(filePath);
+  const prev = existed ? await fs36.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block);
   const printable = displayPath(workspaceRoot, filePath);
   if (dryRun) {
-    if (!prev) {
+    if (!existed) {
       say(createUnifiedDiff(printable, "", next));
     } else if (hasTextChanged(prev, next)) {
       say(createUnifiedDiff(printable, prev, next));
@@ -6804,31 +7570,33 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
     }
     return filePath;
   }
-  if (hasTextChanged(prev, next) && prev.length > 0) {
-    const diffText = createUnifiedDiff(printable, prev, next);
-    const summary = summarizeDiff(diffText);
-    say(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
+  if (!existed || hasTextChanged(prev, next)) {
+    if (existed) {
+      const diffText = createUnifiedDiff(printable, prev, next);
+      const summary = summarizeDiff(diffText);
+      say(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
+    }
+    await writeText(filePath, next);
   }
-  await writeText(filePath, next);
   return filePath;
 }
 
 // src/commands/workspace/setup.ts
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path43.resolve(start);
+  let dir = path50.resolve(start);
   for (; ; ) {
-    if (existsSync4(path43.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path43.dirname(dir);
-    if (parent === dir) return path43.resolve(start);
+    if (existsSync4(path50.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path50.dirname(dir);
+    if (parent === dir) return path50.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path43.resolve(workspaceRoot, repoPath) === path43.resolve(workspaceRoot);
+  return path50.resolve(workspaceRoot, repoPath) === path50.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path43.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path50.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -6855,7 +7623,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path43.resolve(workspaceRoot, repo.path);
+    const repoRoot = path50.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -6926,7 +7694,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
       const status = statusByName.get(repo.name);
       const role = repo.role ?? status?.roles?.[0] ?? "auto";
       if (status?.status === "ok") {
-        const lock = await checkLock(path43.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path50.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -6988,6 +7756,91 @@ Workspace setup complete: ${ok} ok, ${failed} failed. Wrote ${written.length} fi
   return result;
 }
 
+// src/commands/workspace/undo.ts
+import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
+import path51 from "node:path";
+import fs37 from "fs-extra";
+var WORKSPACE_AGGREGATE_FILES = [
+  "workspace-summary.json",
+  "dependency-ownership-map.json",
+  "cross-repo-summary.md",
+  "workspace-context-map.json"
+];
+async function runWorkspaceUndo(workspaceRoot, options = {}) {
+  const config = await readWorkspaceConfig(workspaceRoot);
+  if (!config) {
+    error(`Missing or malformed ${WORKSPACE_FILE}. Nothing to undo.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (config.repos.length === 0) {
+    log(`No repos configured in ${WORKSPACE_FILE}.`);
+  }
+  if (!options.yes) {
+    const ok = await confirm(
+      `Undo haus setup for ${config.repos.length} repo(s) in this workspace, plus workspace-root artifacts?`
+    );
+    if (!ok) {
+      log("Cancelled.");
+      return;
+    }
+  }
+  let anyRepoFailed = false;
+  for (const repo of config.repos) {
+    const repoRoot = path51.resolve(workspaceRoot, repo.path);
+    log(`
+\u2192 ${repo.name} (${repo.path})`);
+    try {
+      if (!existsSync5(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+        throw new Error(`Repo path is not a directory: ${repo.path}`);
+      }
+      await runUndo({ yes: true, root: repoRoot });
+    } catch (err) {
+      anyRepoFailed = true;
+      warn(`Undo failed for ${repo.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const rel of WORKSPACE_AGGREGATE_FILES) {
+    const abs = hausPath(workspaceRoot, rel);
+    if (await fs37.pathExists(abs)) {
+      await fs37.remove(abs);
+      log(`Removed ${path51.relative(workspaceRoot, abs)}`);
+    }
+  }
+  const manifestFile = manifestPath(workspaceRoot);
+  if (await fs37.pathExists(manifestFile)) {
+    await fs37.remove(manifestFile);
+    log(`Removed ${path51.relative(workspaceRoot, manifestFile)}`);
+  }
+  const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
+  if (await fs37.pathExists(workspaceMdPath)) {
+    await fs37.remove(workspaceMdPath);
+    log(`Removed ${path51.relative(workspaceRoot, workspaceMdPath)}`);
+  } else {
+    const claudeMdPath = path51.join(workspaceRoot, "CLAUDE.md");
+    if (existsSync5(claudeMdPath)) {
+      const prev = await readText(claudeMdPath);
+      if (prev?.includes(BLOCK_BEGIN)) {
+        const next = stripHausBlock(prev);
+        if (next.length === 0) {
+          await fs37.remove(claudeMdPath);
+          log("Removed CLAUDE.md (only contained the workspace haus import block).");
+        } else {
+          await fs37.writeFile(claudeMdPath, next, "utf8");
+          log("Removed haus import block from CLAUDE.md (user content preserved).");
+        }
+      }
+    }
+  }
+  log(`${WORKSPACE_FILE} left in place \u2014 it's your own config, not haus-owned output.`);
+  if (anyRepoFailed) {
+    process.exitCode = 1;
+    warn("Workspace undo finished with at least one repo failure \u2014 see above.");
+  } else {
+    log("Workspace undo complete.");
+  }
+}
+
 // src/commands/workspace.ts
 function normalizeOnly(only) {
   if (!only) return void 0;
@@ -7016,7 +7869,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path44.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path52.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -7038,9 +7891,9 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path44.resolve(workspaceRoot, repo.path);
+    const repoRoot = path52.resolve(workspaceRoot, repo.path);
     try {
-      if (!existsSync5(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+      if (!existsSync6(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
       }
       const result = await scanProject(repoRoot);
@@ -7092,13 +7945,16 @@ async function runWorkspace(action, options = {}) {
     case "doctor":
       await runWorkspaceDoctor(workspaceRoot, { json: options.json });
       return;
+    case "undo":
+      await runWorkspaceUndo(workspaceRoot, { yes: options.yes });
+      return;
   }
 }
 
 // src/cli.ts
 function cliVersion() {
   try {
-    const pkgPath = path45.join(packageRoot(), "package.json");
+    const pkgPath = path53.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -7108,7 +7964,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path45.join(packageRoot(), "package.json");
+    const pkgPath = path53.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -7139,8 +7995,17 @@ program.command("apply").option("--dry-run").option("--write").option("--select"
 ).option(
   "--refill-config",
   "Fill still-blank fields in an existing workflow-config.md without touching edited ones"
-).option("--force", "Overwrite user-modified managed workflow files").action(runApply);
+).option("--force", "Overwrite user-modified managed workflow files").option(
+  "--prune",
+  "Remove lock-tracked catalog items no longer in the current recommendation (hash-gated, backed up first)"
+).action(runApply);
 program.command("undo").option("-y, --yes", "Skip confirmation").action(runUndo);
+var backups = program.command("backups");
+backups.command("list").description("List backups under .haus-workflow/backups/").action(() => runBackups("list"));
+backups.command("restore <id>").description("Restore a specific backup by id (see `haus backups list`)").option("-y, --yes", "Skip confirmation").action((id, opts) => runBackups("restore", { id, yes: opts.yes }));
+backups.command("prune").description("Delete old backups by age and/or count (requires --older-than or --keep)").option("--older-than <days>", "Remove backups older than N days").option("--keep <n>", "Keep only the N most recent backups").option("-y, --yes", "Skip confirmation").action(
+  (opts) => runBackups("prune", { olderThan: opts.olderThan, keep: opts.keep, yes: opts.yes })
+);
 program.command("explain-recommendation").option("--json").action(runExplainRecommendation);
 program.command("init").option("--json").action(runInit);
 program.command("clone").description("Clone a single git repository by URL").argument("<url>", "Git URL to clone").argument("[dir]", "Target directory (default: repo name derived from the URL)").option("--dry-run", "Print what would happen without cloning").action(
@@ -7149,7 +8014,7 @@ program.command("clone").description("Clone a single git repository by URL").arg
 program.command("refresh").action(runRefresh);
 program.command("catalog-audit").action(runCatalogAudit);
 program.command("validate-catalog").argument("[manifest]").action(runValidateCatalog);
-program.command("update").option("--check").option("--from-hook", "Emit JSON for the Claude Code SessionStart hook (silent if up to date)").action(runUpdate);
+program.command("update").option("--check").option("--fast", "With --check, skip per-item content hashing (cheap count+ref only)").option("--from-hook", "Emit JSON for the Claude Code SessionStart hook (silent if up to date)").action(runUpdate);
 program.command("install").option("--dry-run").option("--force").option("--check", "Exit non-zero if any HAUS-MANAGED file is out of date").option("--postinstall", "Run by the npm postinstall hook; prints a plain-language change notice").action(runInstall);
 program.command("scaffold [ids...]").description(
   "Copy catalog config items (ESLint, Prettier) into the project root. Pass item IDs to scaffold specific items, or omit to scaffold all available config items."
@@ -7176,6 +8041,7 @@ workspace.command("discover").description("Auto-find member repos and write/merg
 workspace.command("scan").description("Aggregate a cross-repo summary from a fast scan of each repo").option("--json", "Output the written artifact paths as JSON").action((opts) => runWorkspace("scan", opts));
 workspace.command("setup").description("Per-repo setup loop + workspace layer + manifest").option("--write", "Apply changes (default previews only)").option("--dry-run", "Preview changes without writing").option("--json", "Emit machine-readable per-repo output").option("--continue-on-error", "Keep going past a failed repo (default fail-fast)").option("--only <names>", "Restrict to comma-separated repo names").action((opts) => runWorkspace("setup", opts));
 workspace.command("doctor").description("Report workspace drift against the manifest").option("--json", "Output the manifest and drift array as JSON").action((opts) => runWorkspace("doctor", opts));
+workspace.command("undo").description("Revert haus setup for every configured repo, plus workspace-root artifacts").option("-y, --yes", "Skip confirmation").action((opts) => runWorkspace("undo", opts));
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   error(message);