@haus-tech/haus-workflow 1.5.4 → 1.5.6

package/dist/cli.js

@@ -60,11 +60,11 @@ var init_exec = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
-import path23 from "node:path";
+import path24 from "node:path";
 import checkbox from "@inquirer/checkbox";
 
 // src/catalog/load-catalog.ts
@@ -185,6 +185,14 @@ async function listFiles(root, patterns) {
 function hashText(value) {
   return `sha256-${crypto.createHash("sha256").update(value).digest("hex")}`;
 }
+function resolveContainedPath(root, rel) {
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(root, rel);
+  if (resolved === resolvedRoot) return null;
+  const prefix = resolvedRoot.endsWith(path.sep) ? resolvedRoot : resolvedRoot + path.sep;
+  if (!resolved.startsWith(prefix)) return null;
+  return resolved;
+}
 async function mapWithConcurrency(items, fn, concurrency = 24) {
   const size = Number.isFinite(concurrency) ? Math.max(1, Math.floor(concurrency)) : 24;
   const results = new Array(items.length);
@@ -685,10 +693,17 @@ function validateReferences(itemId, references) {
   if (references === void 0) return null;
   if (!isStringArray(references)) return `${itemId}: references must be a string array`;
   for (const ref of references) {
-    if (/^https?:\/\//i.test(ref)) {
-      if (!/^https:\/\//i.test(ref)) {
-        return `${itemId}: reference must be https:// URL: ${ref}`;
-      }
+    let parsed;
+    try {
+      parsed = new URL(ref);
+    } catch {
+      return `${itemId}: reference is not a valid URL: ${ref}`;
+    }
+    if (parsed.protocol === "http:") {
+      return `${itemId}: reference uses insecure http:// URL: ${ref}`;
+    }
+    if (parsed.protocol !== "https:") {
+      return `${itemId}: reference must be https:// URL: ${ref}`;
     }
   }
   return null;
@@ -743,16 +758,29 @@ function validateCuratedProvenance(item) {
   if (!RISK_LEVELS.has(item.riskLevel)) {
     return `${item.id}: invalid riskLevel "${item.riskLevel}"`;
   }
-  if (item.useMode !== void 0 && !USE_MODES.has(String(item.useMode))) {
+  if (!isNonEmptyString(item.originSourceId)) {
+    return `${item.id}: curated item missing originSourceId`;
+  }
+  if (!isNonEmptyString(item.originUrl)) {
+    return `${item.id}: curated item missing originUrl`;
+  }
+  if (!isNonEmptyString(item.useMode)) {
+    return `${item.id}: curated item missing useMode`;
+  }
+  if (!USE_MODES.has(item.useMode)) {
     return `${item.id}: invalid useMode "${item.useMode}"`;
   }
-  if (item.licenseConfidence !== void 0 && !LICENSE_CONFIDENCES.has(String(item.licenseConfidence))) {
+  if (!isNonEmptyString(item.license)) {
+    return `${item.id}: curated item missing license`;
+  }
+  if (!isNonEmptyString(item.licenseConfidence)) {
+    return `${item.id}: curated item missing licenseConfidence`;
+  }
+  if (!LICENSE_CONFIDENCES.has(item.licenseConfidence)) {
     return `${item.id}: invalid licenseConfidence "${item.licenseConfidence}"`;
   }
-  if (item.originUrl !== void 0) {
-    if (typeof item.originUrl !== "string" || !item.originUrl.startsWith("https://")) {
-      return `${item.id}: originUrl must be an https:// URL`;
-    }
+  if (typeof item.originUrl !== "string" || !item.originUrl.startsWith("https://")) {
+    return `${item.id}: originUrl must be an https:// URL`;
   }
   return null;
 }
@@ -774,9 +802,6 @@ function isRequiresAnyClause(value) {
   if (!REQUIRES_ANY_KEYS.includes(key)) return false;
   return typeof value[key] === "string";
 }
-function isRequiresAnyArray(value) {
-  return Array.isArray(value) && value.every(isRequiresAnyClause);
-}
 function safeParse(json) {
   return JSON.parse(json, (key, value) => {
     if (POLLUTION_KEYS.has(key)) return void 0;
@@ -803,6 +828,7 @@ function parseManifest(json) {
   const items = [];
   const seenIds = /* @__PURE__ */ new Set();
   const seenPaths = /* @__PURE__ */ new Set();
+  const warnings = [];
   for (let i = 0; i < root.items.length; i++) {
     const raw = root.items[i];
     if (!raw || typeof raw !== "object") {
@@ -837,8 +863,21 @@ function parseManifest(json) {
     if (!isStringArray2(item.repoRoles)) {
       return { ok: false, error: `${item.id}: repoRoles must be a string array` };
     }
-    if (item.requiresAny !== void 0 && !isRequiresAnyArray(item.requiresAny)) {
-      return { ok: false, error: `${item.id}: requiresAny must be an array of clause objects` };
+    if (item.requiresAny !== void 0) {
+      if (!Array.isArray(item.requiresAny)) {
+        return { ok: false, error: `${item.id}: requiresAny must be an array of clause objects` };
+      }
+      const kept = [];
+      for (const clause of item.requiresAny) {
+        if (isRequiresAnyClause(clause)) {
+          kept.push(clause);
+        } else {
+          warnings.push(
+            `${item.id}: dropping unrecognized requiresAny clause (catalog schema evolved ahead of this CLI version) \u2014 ${JSON.stringify(clause)}`
+          );
+        }
+      }
+      item.requiresAny = kept;
     }
     if (typeof item.tokenEstimate !== "number" || !Number.isFinite(item.tokenEstimate)) {
       return { ok: false, error: `${item.id}: tokenEstimate must be a finite number` };
@@ -855,7 +894,7 @@ function parseManifest(json) {
   if (formerIdFailures.length > 0) {
     return { ok: false, error: formerIdFailures[0] };
   }
-  return { ok: true, manifest: { version: root.version, items } };
+  return { ok: true, manifest: { version: root.version, items }, warnings };
 }
 
 // src/catalog/remote-catalog/manifest.ts
@@ -868,6 +907,7 @@ async function fetchRemoteManifest() {
     warn(`Remote manifest failed schema validation: ${parsed.error}`);
     return null;
   }
+  for (const warning of parsed.warnings) warn(warning);
   if (!parsed.manifest.items.length) return null;
   return parsed.manifest;
 }
@@ -929,6 +969,7 @@ var validation_rules_default = {
     "haus",
     "security",
     "quality",
+    "a11y",
     "frontend",
     "backend",
     "testing",
@@ -1552,7 +1593,7 @@ function summarizeGitignoredHausDirs(paths) {
 }
 
 // src/claude/write-claude-files.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import fs18 from "fs-extra";
 
 // src/catalog/former-ids.ts
@@ -1608,8 +1649,199 @@ function findOrphanedLockEntries(lock, recommendedIds) {
   );
 }
 
-// src/update/hash-installed.ts
+// src/scanner/detection.ts
 import path10 from "node:path";
+
+// src/security/sensitive-paths.ts
+var DENY_PATHS = [
+  "*.pem",
+  "*.key",
+  "*.p12",
+  "*.pfx",
+  "id_rsa",
+  "id_ed25519",
+  "customer-data",
+  "secrets",
+  "certs"
+];
+var DENY_DIRS = /* @__PURE__ */ new Set(["customer-data", "secrets", "certs"]);
+var DENY_PATH_REGEXES = [
+  /(^|\/)[^/]+\.pem$/i,
+  /(^|\/)[^/]+\.key$/i,
+  /(^|\/)[^/]+\.p12$/i,
+  /(^|\/)[^/]+\.pfx$/i,
+  /(^|\/)id_rsa$/i,
+  /(^|\/)id_ed25519$/i,
+  /(^|\/)customer-data(\/|$)/i,
+  /(^|\/)secrets(\/|$)/i,
+  /(^|\/)certs(\/|$)/i
+];
+function normalizePathForMatch(candidate) {
+  return candidate.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
+}
+var ASK_PATHS = [
+  { pattern: ".env", tools: ["Edit", "Write"] },
+  { pattern: ".env.*", tools: ["Edit", "Write"] },
+  { pattern: "storage/logs/**", tools: ["Edit", "Write"] },
+  { pattern: "exports/**", tools: ["Edit", "Write"] },
+  { pattern: "*.dump", tools: ["Read", "Edit", "Write"] },
+  { pattern: "*.backup", tools: ["Read", "Edit", "Write"] },
+  { pattern: "*.bak", tools: ["Read", "Edit", "Write"] },
+  { pattern: "wp-content/uploads/**", tools: ["Read", "Edit", "Write"] },
+  { pattern: "uploads/**", tools: ["Read", "Edit", "Write"] }
+];
+var SENSITIVE_PATH_REGEXES = [
+  /^\.env(\.|$)/,
+  /(^|\/)\.env(\.|$)/,
+  /\.pem$/,
+  /\.key$/,
+  /\.p12$/,
+  /\.pfx$/,
+  /\.sql$/,
+  /\.dump$/,
+  /customer-data/,
+  /exports/,
+  /certs/,
+  /secrets/,
+  /(^|\/)storage\/logs(\/|$)/,
+  /(^|\/)wp-content\/uploads(\/|$)/,
+  /(^|\/)uploads(\/|$)/
+];
+var SENSITIVE_ITEM_KEYWORDS = [
+  ".env",
+  "secrets",
+  "certs",
+  "customer-data",
+  "exports",
+  ".pem",
+  ".key"
+];
+
+// src/utils/audit-checks.ts
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+
+// src/scanner/detection.ts
+var UNSUPPORTED_MARKERS = {
+  "requirements.txt": "python",
+  "pyproject.toml": "python",
+  "go.mod": "go",
+  "Cargo.toml": "rust",
+  "pom.xml": "java",
+  "build.gradle": "java",
+  "build.gradle.kts": "java",
+  Gemfile: "ruby"
+};
+var WEAK_STACK_SIGNALS = /* @__PURE__ */ new Set(["missing-prettier", "missing-eslint"]);
+function computeDetectionStatus(roles, stacks, unsupportedSignals) {
+  const hasRealStack = Object.entries(stacks).some(
+    ([bucket, names]) => bucket !== "packageManagers" && names.some((n) => !WEAK_STACK_SIGNALS.has(n))
+  );
+  const hasRealSignal = roles.length > 0 || hasRealStack;
+  if (!hasRealSignal) return "unknown";
+  return unsupportedSignals.length > 0 ? "partial" : "supported";
+}
+function describeUnknownDetection(unsupportedSignals, isLinkedWorktree) {
+  const markers = unsupportedSignals.join(", ");
+  const base = markers ? `Stack not recognised \u2014 detected ${markers}, which haus does not support.` : "Stack not recognised \u2014 no supported framework detected.";
+  const worktreeNote = isLinkedWorktree ? "You're running from inside a git worktree \u2014 sibling repos may not be on disk here, so this could be a false zero-signal reading rather than truly no stack." : "";
+  return [base, worktreeNote, "Only stack-agnostic workflow and security guidance is applied."].filter(Boolean).join(" ");
+}
+function blocked(rel) {
+  return SENSITIVE_PATH_REGEXES.some((x) => x.test(rel));
+}
+function dependencyVersionMap(pkg, composer) {
+  const versions = /* @__PURE__ */ new Map();
+  const pushObj = (obj) => {
+    if (!isRecord(obj)) return;
+    for (const key of Object.keys(obj)) {
+      if (versions.has(key)) continue;
+      const value = obj[key];
+      versions.set(key, typeof value === "string" ? value : "");
+    }
+  };
+  pushObj(pkg?.dependencies);
+  pushObj(pkg?.devDependencies);
+  pushObj(composer?.require);
+  pushObj(composer?.["require-dev"]);
+  return versions;
+}
+function finalizeRoles(registryRoles, deps, files) {
+  const roles = new Set(registryRoles);
+  const hasWpConfig = files.some((f) => f.endsWith("wp-config.php"));
+  const hasBedrockLayout = files.some((f) => f.includes("web/app")) || deps.includes("roots/wordpress");
+  if (hasWpConfig && hasBedrockLayout) {
+    roles.add("wordpress-bedrock-site");
+    roles.add("wordpress-site");
+  } else if (hasWpConfig) {
+    roles.add("wordpress-vanilla-site");
+    roles.add("wordpress-site");
+  } else if (deps.includes("roots/wordpress")) {
+    roles.add("wordpress-bedrock-site");
+    roles.add("wordpress-site");
+  }
+  return [...roles].sort();
+}
+function collectUnsupportedSignals(files) {
+  return [
+    ...new Set(
+      files.map((f) => UNSUPPORTED_MARKERS[path10.basename(f)]).filter((s) => Boolean(s))
+    )
+  ].sort();
+}
+
+// src/recommender/policies.ts
+var UNSUPPORTED = FORBIDDEN_TAGS;
+function matchRequiresAny(clauses, ctx) {
+  for (const clause of clauses) {
+    if ("stack" in clause) {
+      if (ctx.stackSet.has(clause.stack.toLowerCase())) {
+        return { matched: true, signal: `stack:${clause.stack}` };
+      }
+    } else if ("dependency" in clause) {
+      if (ctx.depSet.has(clause.dependency.toLowerCase())) {
+        return { matched: true, signal: `dependency:${clause.dependency}` };
+      }
+    } else if ("packageNamePattern" in clause) {
+      const pattern = clause.packageNamePattern.toLowerCase();
+      const prefix = pattern.endsWith("*") ? pattern.slice(0, -1) : pattern;
+      for (const dep2 of ctx.depSet) {
+        if (pattern.endsWith("*") ? dep2.startsWith(prefix) : dep2 === pattern) {
+          return {
+            matched: true,
+            signal: `packageNamePattern:${clause.packageNamePattern}`
+          };
+        }
+      }
+    } else if ("role" in clause) {
+      if (ctx.roleSet.has(clause.role.toLowerCase())) {
+        return { matched: true, signal: `role:${clause.role}` };
+      }
+    }
+  }
+  return { matched: false };
+}
+function describeRequiresAny(clauses) {
+  return clauses.map((c) => {
+    if ("stack" in c) return `stack=${c.stack}`;
+    if ("dependency" in c) return `dependency=${c.dependency}`;
+    if ("packageNamePattern" in c) return `packageNamePattern=${c.packageNamePattern}`;
+    if ("role" in c) return `role=${c.role}`;
+    return "unknown";
+  }).join(" | ");
+}
+function mergeRecommendationWarnings(context, isLinkedWorktree = false) {
+  const markers = context.unsupportedSignals?.join(", ");
+  const statusLines = context.detectionStatus === "unknown" ? [describeUnknownDetection(context.unsupportedSignals ?? [], isLinkedWorktree)] : context.detectionStatus === "partial" && markers ? [
+    `Partially supported \u2014 found unsupported ${markers} alongside recognised stacks; guidance covers the supported parts only.`
+  ] : [];
+  const riskLines = (context.securityRisks?.length ?? 0) > 0 ? [`Scan reported security signals: ${context.securityRisks.join("; ")}`] : [];
+  return [.../* @__PURE__ */ new Set([...statusLines, ...context.warnings, ...riskLines])];
+}
+
+// src/update/hash-installed.ts
+import path11 from "node:path";
 import fg2 from "fast-glob";
 import fs7 from "fs-extra";
 
@@ -1666,7 +1898,7 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
   const normalized = [...new Set(relPaths.map((p) => p.replace(/\\/g, "/")))].sort();
   const fileDigests = [];
   for (const rel of normalized) {
-    const abs = path10.join(root, rel);
+    const abs = path11.join(root, rel);
     if (!await fs7.pathExists(abs)) continue;
     const stat = followSymlinks ? await fs7.stat(abs) : await fs7.lstat(abs);
     if (!followSymlinks && stat.isSymbolicLink()) continue;
@@ -1683,9 +1915,9 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
       followSymbolicLinks: followSymlinks
     });
     for (const sub of inner.sort()) {
-      const absFile = path10.join(abs, sub);
+      const absFile = path11.join(abs, sub);
       if (!followSymlinks && (await fs7.lstat(absFile)).isSymbolicLink()) continue;
-      const relFile = path10.join(rel, sub).replace(/\\/g, "/");
+      const relFile = path11.join(rel, sub).replace(/\\/g, "/");
       const body = await fs7.readFile(absFile);
       fileDigests.push({ rel: relFile, digest: digestFileContent(body) });
     }
@@ -1757,18 +1989,18 @@ function buildAllowRules() {
 }
 
 // src/install/settings-merge.ts
-import path12 from "node:path";
+import path13 from "node:path";
 import fs9 from "fs-extra";
 
 // src/install/manifest.ts
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 var MANIFEST_SCHEMA = "haus-install-manifest/1";
 function globalClaudeDir() {
-  return path11.join(os3.homedir(), ".claude");
+  return path12.join(os3.homedir(), ".claude");
 }
 function hausManifestPath() {
-  return path11.join(globalClaudeDir(), "haus", "install-manifest.json");
+  return path12.join(globalClaudeDir(), "haus", "install-manifest.json");
 }
 async function readManifest() {
   return readJson(hausManifestPath());
@@ -1788,7 +2020,7 @@ function buildManifest(source, files, hooks) {
 
 // src/install/settings-merge.ts
 function settingsJsonPath() {
-  return path12.join(globalClaudeDir(), "settings.json");
+  return path13.join(globalClaudeDir(), "settings.json");
 }
 async function readSettings() {
   const filePath = settingsJsonPath();
@@ -2017,71 +2249,6 @@ var ASK_COMMANDS = [
   "php artisan migrate --force"
 ];
 
-// src/security/sensitive-paths.ts
-var DENY_PATHS = [
-  "*.pem",
-  "*.key",
-  "*.p12",
-  "*.pfx",
-  "id_rsa",
-  "id_ed25519",
-  "customer-data",
-  "secrets",
-  "certs"
-];
-var DENY_DIRS = /* @__PURE__ */ new Set(["customer-data", "secrets", "certs"]);
-var DENY_PATH_REGEXES = [
-  /(^|\/)[^/]+\.pem$/i,
-  /(^|\/)[^/]+\.key$/i,
-  /(^|\/)[^/]+\.p12$/i,
-  /(^|\/)[^/]+\.pfx$/i,
-  /(^|\/)id_rsa$/i,
-  /(^|\/)id_ed25519$/i,
-  /(^|\/)customer-data(\/|$)/i,
-  /(^|\/)secrets(\/|$)/i,
-  /(^|\/)certs(\/|$)/i
-];
-function normalizePathForMatch(candidate) {
-  return candidate.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
-}
-var ASK_PATHS = [
-  { pattern: ".env", tools: ["Edit", "Write"] },
-  { pattern: ".env.*", tools: ["Edit", "Write"] },
-  { pattern: "storage/logs/**", tools: ["Edit", "Write"] },
-  { pattern: "exports/**", tools: ["Edit", "Write"] },
-  { pattern: "*.dump", tools: ["Read", "Edit", "Write"] },
-  { pattern: "*.backup", tools: ["Read", "Edit", "Write"] },
-  { pattern: "*.bak", tools: ["Read", "Edit", "Write"] },
-  { pattern: "wp-content/uploads/**", tools: ["Read", "Edit", "Write"] },
-  { pattern: "uploads/**", tools: ["Read", "Edit", "Write"] }
-];
-var SENSITIVE_PATH_REGEXES = [
-  /^\.env(\.|$)/,
-  /(^|\/)\.env(\.|$)/,
-  /\.pem$/,
-  /\.key$/,
-  /\.p12$/,
-  /\.pfx$/,
-  /\.sql$/,
-  /\.dump$/,
-  /customer-data/,
-  /exports/,
-  /certs/,
-  /secrets/,
-  /(^|\/)storage\/logs(\/|$)/,
-  /(^|\/)wp-content\/uploads(\/|$)/,
-  /(^|\/)uploads(\/|$)/
-];
-var SENSITIVE_ITEM_KEYWORDS = [
-  ".env",
-  "secrets",
-  "certs",
-  "customer-data",
-  "exports",
-  ".pem",
-  ".key"
-];
-
 // src/security/ask-rules.ts
 function buildAskRules() {
   const rules = [];
@@ -2103,8 +2270,8 @@ function buildDenyRules() {
   for (const command of DENY_COMMANDS) {
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path72 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path72) ? `${path72}/**` : path72;
+  for (const path73 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path73) ? `${path73}/**` : path73;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -2183,24 +2350,28 @@ async function applyProjectSettingsMerge(root) {
 }
 
 // src/claude/superpowers-install.ts
-import path13 from "node:path";
+import path14 from "node:path";
 import fg3 from "fast-glob";
 import fs10 from "fs-extra";
 var SUPERPOWERS_ORIGIN_SOURCE_ID = "superpowers-pcvelz";
 var PATH_REWRITES = [
   ["skills/shared/", ".claude/skills/shared/"]
 ];
+var PREFIX_REWRITES = ["superpowers-extended-cc:"];
 function rewriteSuperpowersMarkdown(text) {
   let out = text;
   for (const [from, to] of PATH_REWRITES) {
     out = out.split(from).join(to);
   }
+  for (const prefix of PREFIX_REWRITES) {
+    out = out.split(prefix).join("");
+  }
   return out;
 }
 async function rewriteMarkdownTree(dir) {
   const files = await fg3("**/*.md", { cwd: dir, onlyFiles: true, dot: true });
   for (const rel of files) {
-    const abs = path13.join(dir, rel);
+    const abs = path14.join(dir, rel);
     const text = await fs10.readFile(abs, "utf8");
     const rewritten = rewriteSuperpowersMarkdown(text);
     if (rewritten !== text) {
@@ -2208,10 +2379,24 @@ async function rewriteMarkdownTree(dir) {
     }
   }
 }
+async function extraDestFiles(sourcePath, destination) {
+  const [sourceFiles, destFiles] = await Promise.all([
+    fg3("**/*", { cwd: sourcePath, onlyFiles: true, dot: true }),
+    fg3("**/*", { cwd: destination, onlyFiles: true, dot: true })
+  ]);
+  const sourceSet = new Set(sourceFiles);
+  return destFiles.filter((f) => !sourceSet.has(f));
+}
 async function installCatalogSkill(sourcePath, destination, opts) {
   if (opts.dryRun) return;
-  await fs10.ensureDir(path13.dirname(destination));
+  await fs10.ensureDir(path14.dirname(destination));
   if (await fs10.pathExists(destination)) {
+    const extra = await extraDestFiles(sourcePath, destination);
+    if (extra.length > 0) {
+      warn(
+        `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
+      );
+    }
     await fs10.remove(destination);
   }
   await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
@@ -2220,17 +2405,23 @@ async function installCatalogSkill(sourcePath, destination, opts) {
   }
 }
 async function installSuperpowersShared(contentRoot, projectRoot, dryRun) {
-  const source = path13.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
+  const source = path14.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
   if (!await fs10.pathExists(source)) return null;
   const destination = claudePath(projectRoot, "skills", "shared");
-  if (dryRun) return path13.relative(projectRoot, destination);
-  await fs10.ensureDir(path13.dirname(destination));
+  if (dryRun) return path14.relative(projectRoot, destination);
+  await fs10.ensureDir(path14.dirname(destination));
   if (await fs10.pathExists(destination)) {
+    const extra = await extraDestFiles(source, destination);
+    if (extra.length > 0) {
+      warn(
+        `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
+      );
+    }
     await fs10.remove(destination);
   }
   await fs10.copy(source, destination, { overwrite: true, errorOnExist: false });
   await rewriteMarkdownTree(destination);
-  return path13.relative(projectRoot, destination);
+  return path14.relative(projectRoot, destination);
 }
 
 // src/claude/verify-hooks-contract.ts
@@ -2345,7 +2536,7 @@ async function verifyProjectSettingsHooksContract(root) {
 }
 
 // src/claude/write-decisions-seed.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import fs12 from "fs-extra";
 
 // library/catalog/decisions-triggers.json
@@ -2389,8 +2580,8 @@ Why we chose X \u2014 short, dated, write-once decision log for humans and agent
 | --- | ----- | -------------- | ------ |
 `;
 async function writeDecisionsSeed(root, dryRun) {
-  const decisionsDir = path14.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const readmePath = path14.join(decisionsDir, "README.md");
+  const decisionsDir = path15.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const readmePath = path15.join(decisionsDir, "README.md");
   if (await fs12.pathExists(readmePath)) return null;
   if (!dryRun) await fs12.ensureDir(decisionsDir);
   await writeManagedText(root, readmePath, SEED_README, dryRun);
@@ -2398,7 +2589,7 @@ async function writeDecisionsSeed(root, dryRun) {
 }
 
 // src/claude/write-prettierignore.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import fs13 from "fs-extra";
 var PRETTIERIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var PRETTIERIGNORE_END = "# HAUS:END haus-managed";
@@ -2467,7 +2658,7 @@ ${block}
 `;
 }
 async function writePrettierIgnore(root, dryRun) {
-  const filePath = path15.join(root, ".prettierignore");
+  const filePath = path16.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);
@@ -2475,7 +2666,7 @@ async function writePrettierIgnore(root, dryRun) {
 }
 
 // src/claude/write-root-claude-md.ts
-import path16 from "node:path";
+import path17 from "node:path";
 import fs14 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
@@ -2553,7 +2744,7 @@ ${block}
 `;
 }
 async function writeRootClaudeMd(root, dryRun) {
-  const filePath = path16.join(root, "CLAUDE.md");
+  const filePath = path17.join(root, "CLAUDE.md");
   const block = buildImportBlock();
   const prev = await fs14.pathExists(filePath) ? await fs14.readFile(filePath, "utf8") : "";
   const next = injectHausBlock(prev, block);
@@ -2562,11 +2753,11 @@ async function writeRootClaudeMd(root, dryRun) {
 }
 
 // src/claude/write-workflow-config.ts
-import path18 from "node:path";
+import path19 from "node:path";
 import fs16 from "fs-extra";
 
 // src/claude/derive-workflow-config.ts
-import path17 from "node:path";
+import path18 from "node:path";
 import fs15 from "fs-extra";
 function binCmd(pm, bin, args) {
   const tail = args ? ` ${args}` : "";
@@ -2576,7 +2767,7 @@ function binCmd(pm, bin, args) {
 }
 async function deriveWorkflowConfig(root, ctx) {
   const pm = ctx.packageManager === "unknown" ? "npm" : ctx.packageManager;
-  const pkg = await readJson(path17.join(root, "package.json"));
+  const pkg = await readJson(path18.join(root, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = new Set(ctx.dependencies);
   const stacks = Object.values(ctx.detectedStacks ?? {}).flat();
@@ -2586,7 +2777,7 @@ async function deriveWorkflowConfig(root, ctx) {
     return null;
   };
   const hasDep = (name) => deps.has(name);
-  const exists = (rel) => fs15.pathExistsSync(path17.join(root, rel));
+  const exists = (rel) => fs15.pathExistsSync(path18.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;
@@ -2661,7 +2852,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   const ctx = await readJson(hausPath(root, "context-map.json")) ?? {
     ...FALLBACK_CONTEXT,
     root,
-    repoName: path18.basename(root)
+    repoName: path19.basename(root)
   };
   const values = await deriveWorkflowConfig(root, ctx);
   if (exists) {
@@ -2706,7 +2897,8 @@ function checkManagedTamper(body, storedHash, templateContent) {
 // 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} -->`;
+  const hashAttr = contentHash === void 0 ? "" : ` hash=${contentHash}`;
+  return `<!-- HAUS-MANAGED id=${STABLE_ID} v=${SCHEMA_VERSION} source=@haus-tech/haus-workflow@${pkgVersion}${hashAttr} -->`;
 }
 async function writeWorkflow(root, pkgVersion, dryRun, force = false) {
   const templateContent = await readWorkflowTemplate({ dryRun });
@@ -2747,12 +2939,12 @@ ${templateContent}`;
       return null;
     }
     if (verdict.status === "legacy-diverged" && !force) {
-      const migratedHeader = makeWorkflowHeader(pkgVersion, hashText(normaliseLF(existingContent)));
+      const migratedHeader = makeWorkflowHeader(pkgVersion);
       const migrated = `${migratedHeader}
 ${existingContent}`;
       if (hasTextChanged(existing, migrated)) {
         if (dryRun) {
-          log(`${printable}: migrating legacy hash header (body preserved)`);
+          log(`${printable}: migrating legacy header (staying hash-less; body preserved)`);
         } else {
           await writeText(destPath, migrated);
         }
@@ -2799,7 +2991,7 @@ async function listFilesRecursive2(dir) {
   const walk = async (current, relPrefix) => {
     const names = await fs18.readdir(current);
     for (const name of names) {
-      const abs = path19.join(current, name);
+      const abs = path20.join(current, name);
       const rel = relPrefix ? `${relPrefix}/${name}` : name;
       const stat = await fs18.lstat(abs);
       if (stat.isSymbolicLink()) {
@@ -2843,8 +3035,8 @@ async function logSkillDryRunDiff(root, sourcePath, destination, itemId, say) {
   for (const rel of sourceFiles) {
     await logFileDryRunDiff(
       root,
-      path19.join(sourcePath, rel),
-      path19.join(destination, rel),
+      path20.join(sourcePath, rel),
+      path20.join(destination, rel),
       itemId,
       say
     );
@@ -2852,7 +3044,7 @@ async function logSkillDryRunDiff(root, sourcePath, destination, itemId, say) {
   const sourceFileSet = new Set(sourceFiles);
   for (const rel of destFiles) {
     if (!sourceFileSet.has(rel)) {
-      say(`${displayPath(root, path19.join(destination, rel))}: would remove (${itemId})`);
+      say(`${displayPath(root, path20.join(destination, rel))}: would remove (${itemId})`);
     }
   }
 }
@@ -2872,7 +3064,9 @@ async function removeLegacyManagedStub(root, relPathSegments, stub, dryRun, say)
 async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   const say = opts.quiet ? () => {
   } : log;
-  const rec = await readJson(hausPath(root, "recommendation.json")) ?? {
+  const recResult = await readJsonDetailed(hausPath(root, "recommendation.json"));
+  const recommendationUnusable = recResult.status !== "ok";
+  const rec = recResult.status === "ok" ? recResult.value : {
     recommended: [],
     skipped: [],
     warnings: [],
@@ -2882,7 +3076,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     estimatedTokenReductionPct: 0
   };
   const pkgRoot = packageRoot();
-  const hausVersion2 = (await readJson(path19.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
+  const hausVersion2 = (await readJson(path20.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);
@@ -2972,6 +3166,9 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   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 prevLockById = new Map(
+    prevLock.filter((entry) => Boolean(entry.id)).map((entry) => [entry.id, entry])
+  );
   const allMigrations = findFormerIdMigrations(
     prevLock.filter((entry) => Boolean(entry.id)),
     manifestItems
@@ -3032,6 +3229,17 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       warn(`Skipping ${item.id}: reviewStatus is deprecated`);
       continue;
     }
+    const manifestItemTags = (manifestItem.tags ?? []).map((t) => t.toLowerCase());
+    if (UNSUPPORTED.some((x) => manifestItemTags.includes(x))) {
+      warn(`Skipping ${item.id}: unsupported stack policy`);
+      continue;
+    }
+    const sensitiveInId = SENSITIVE_ITEM_KEYWORDS.some((x) => item.id.toLowerCase().includes(x));
+    const sensitiveInTags = SENSITIVE_ITEM_KEYWORDS.some((x) => manifestItemTags.includes(x));
+    if (sensitiveInId || sensitiveInTags) {
+      warn(`Skipping ${item.id}: sensitive content policy block`);
+      continue;
+    }
     if (manifestItem.source === "curated") {
       if (manifestItem.reviewStatus !== "approved") {
         curatedReviewStatusSkips++;
@@ -3056,7 +3264,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       );
       continue;
     }
-    const destination = claudePath(root, target, path19.basename(sourcePath));
+    const destination = claudePath(root, target, path20.basename(sourcePath));
     if (await fs18.pathExists(sourcePath)) {
       if (dryRun) {
         if (item.type === "skill") {
@@ -3064,13 +3272,23 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
         } else {
           await logFileDryRunDiff(root, sourcePath, destination, item.id, say);
         }
+      } else if (await skipLocallyEditedItem(
+        root,
+        item.id,
+        prevLockById.get(item.id),
+        opts.force,
+        files,
+        installedPathsByItem,
+        installedIds
+      )) {
+        continue;
       } else if (item.type === "skill") {
         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 = path19.join(sourcePath, relFile);
+          const mdPath = path20.join(sourcePath, relFile);
           const mdContent = await fs18.readFile(mdPath, "utf8");
           const mdValidation = validateCatalogItem(
             {
@@ -3109,17 +3327,17 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           warn(`Skipping ${item.id}: pre-copy validation failed \u2014 ${validation.reason}`);
           continue;
         }
-        await fs18.ensureDir(path19.dirname(destination));
+        await fs18.ensureDir(path20.dirname(destination));
         await fs18.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
-      const relPaths = [path19.relative(root, destination)];
+      const relPaths = [path20.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(path19.join(root, sharedRel));
+          files.push(path20.join(root, sharedRel));
         }
       }
       const current = installedPathsByItem.get(item.id) ?? [];
@@ -3137,18 +3355,31 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     );
   }
   await cleanupStaleCatalogItems(root, cleanupManifestById, dryRun, opts.quiet);
+  const refuseDestructiveLockChange = recommendationUnusable && prevLock.length > 0 && !opts.force;
   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);
+    if (refuseDestructiveLockChange) {
+      warn(
+        "recommendation.json is missing or unreadable \u2014 refusing --prune (every installed item would look orphaned). Run `haus recommend` first, or pass --force to override."
+      );
+    } else {
+      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);
     }
-    await pruneOrphanedCatalogItems(root, prevLock, notOrphaned, dryRun, opts.quiet);
   }
   const installedItems = catalogItems.filter((r) => installedIds.has(r.id));
   if (dryRun) {
+    if (refuseDestructiveLockChange) {
+      say(
+        "[dry-run] recommendation.json is missing or unreadable \u2014 haus.lock.json would be left unchanged. Run `haus recommend` first, or pass --force."
+      );
+      return [...new Set(files)];
+    }
     const prevIds = new Set(
       prevLock.map((e) => e.id ? migrationByOldId.get(e.id) ?? e.id : void 0).filter((id) => Boolean(id))
     );
@@ -3159,6 +3390,12 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     for (const id of removed) say(`[dry-run] haus.lock.json would remove: ${id}`);
     return [...new Set(files)];
   }
+  if (refuseDestructiveLockChange) {
+    warn(
+      "recommendation.json is missing or unreadable \u2014 leaving haus.lock.json unchanged rather than writing an empty lock. Run `haus recommend` first, or pass --force to overwrite anyway."
+    );
+    return [...new Set(files)];
+  }
   const prevRefById = new Map(
     prevLock.filter((e) => e.id && e.catalogRef).map((e) => [migrationByOldId.get(e.id) ?? e.id, e.catalogRef])
   );
@@ -3192,6 +3429,26 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   await writeManagedJson(root, hausPath(root, "haus.lock.json"), lock, false);
   return [...new Set(files)];
 }
+async function skipLocallyEditedItem(root, itemId, prevEntry, force, files, installedPathsByItem, installedIds) {
+  if (!prevEntry || prevEntry.hash === void 0 || force) return false;
+  const existing = await resolveExistingTrackedPaths(root, itemId, prevEntry.paths ?? [], warn);
+  if (existing.length === 0) return false;
+  const currentHash = await hashInstalledPaths(
+    root,
+    existing.map((e) => e.rel)
+  );
+  if (currentHash === prevEntry.hash) return false;
+  warn(
+    `User edited ${itemId} (skipping reinstall): ${existing.map((e) => e.rel).join(", ")} \u2014 use --force to overwrite`
+  );
+  files.push(...existing.map((e) => e.abs));
+  installedPathsByItem.set(
+    itemId,
+    existing.map((e) => e.rel)
+  );
+  installedIds.add(itemId);
+  return true;
+}
 async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, quiet) {
   const say = quiet ? () => {
   } : log;
@@ -3199,26 +3456,25 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
     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);
-    }
+    const existing = await resolveExistingTrackedPaths(root, migration.oldId, relPaths, warn);
     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(", ")}`
+        `Former catalog item ${migration.oldId} has no lock hash \u2014 leaving old paths in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
-    const currentHash = await hashInstalledPaths(root, existing);
+    const currentHash = await hashInstalledPaths(
+      root,
+      existing.map((e) => e.rel)
+    );
     if (currentHash !== entry.hash) {
       warn(
-        `Former catalog item ${migration.oldId} was modified locally \u2014 leaving old paths in place: ${existing.join(", ")}`
+        `Former catalog item ${migration.oldId} was modified locally \u2014 leaving old paths in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
-    for (const rel of existing) {
-      const abs = path19.join(root, rel);
+    for (const { abs } of existing) {
       if (dryRun) {
         say(
           `[dry-run] would remove renamed ${displayPath(root, abs)} (${migration.oldId} \u2192 ${migration.newId})`
@@ -3226,9 +3482,21 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
         continue;
       }
       await fs18.remove(abs);
-      await pruneEmptyDir(path19.dirname(abs));
+      await pruneEmptyDir(path20.dirname(abs));
+    }
+  }
+}
+async function resolveExistingTrackedPaths(root, itemId, relPaths, warnFn) {
+  const existing = [];
+  for (const rel of relPaths) {
+    const abs = resolveContainedPath(root, rel);
+    if (abs === null) {
+      warnFn(`Refusing to touch ${itemId}'s recorded path outside the project root: ${rel}`);
+      continue;
     }
+    if (await fs18.pathExists(abs)) existing.push({ rel, abs });
   }
+  return existing;
 }
 async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet) {
   const say = quiet ? () => {
@@ -3243,33 +3511,32 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet) {
     if (!removedFromManifest && !deprecated) 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);
-    }
+    const existing = await resolveExistingTrackedPaths(root, entry.id, relPaths, warn);
     if (existing.length === 0) continue;
     const pruneReason = deprecated ? "deprecated" : "stale";
     if (entry.hash === void 0) {
       warn(
-        `${deprecated ? "Deprecated" : "Stale"} catalog item ${entry.id} has no lock hash \u2014 leaving in place: ${existing.join(", ")}`
+        `${deprecated ? "Deprecated" : "Stale"} catalog item ${entry.id} has no lock hash \u2014 leaving in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
-    const currentHash = await hashInstalledPaths(root, relPaths);
+    const currentHash = await hashInstalledPaths(
+      root,
+      existing.map((e) => e.rel)
+    );
     if (currentHash !== entry.hash) {
       warn(
-        `${deprecated ? "Deprecated" : "Stale"} catalog item ${entry.id} was modified locally \u2014 leaving in place: ${existing.join(", ")}`
+        `${deprecated ? "Deprecated" : "Stale"} catalog item ${entry.id} was modified locally \u2014 leaving in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
-    for (const rel of existing) {
-      const abs = path19.join(root, rel);
+    for (const { abs } of existing) {
       if (dryRun) {
         say(`[dry-run] would remove ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
         continue;
       }
       await fs18.remove(abs);
-      await pruneEmptyDir(path19.dirname(abs));
+      await pruneEmptyDir(path20.dirname(abs));
       say(`Removed ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
     }
   }
@@ -3280,12 +3547,12 @@ async function backupBeforePrune(root, absPaths, say) {
   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));
+    const rel = path20.relative(root, abs);
+    const backupPath = path20.join(backupRoot, rel);
+    await fs18.ensureDir(path20.dirname(backupPath));
     await fs18.copy(abs, backupPath);
   }
-  say(`Backed up ${absPaths.length} path(s) to ${path19.relative(root, backupRoot)} before pruning.`);
+  say(`Backed up ${absPaths.length} path(s) to ${path20.relative(root, backupRoot)} before pruning.`);
 }
 async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun, quiet) {
   const say = quiet ? () => {
@@ -3297,21 +3564,21 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
     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);
-    }
+    const existing = await resolveExistingTrackedPaths(root, entry.id, relPaths, warn);
     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(", ")}`
+        `Orphaned catalog item ${entry.id} has no lock hash \u2014 leaving in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
-    const currentHash = await hashInstalledPaths(root, relPaths);
+    const currentHash = await hashInstalledPaths(
+      root,
+      existing.map((e) => e.rel)
+    );
     if (currentHash !== entry.hash) {
       warn(
-        `Orphaned catalog item ${entry.id} was modified locally \u2014 leaving in place: ${existing.join(", ")}`
+        `Orphaned catalog item ${entry.id} was modified locally \u2014 leaving in place: ${existing.map((e) => e.rel).join(", ")}`
       );
       continue;
     }
@@ -3320,21 +3587,18 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
   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})`);
+      for (const { abs } of existing) {
+        say(`[dry-run] would prune orphaned ${displayPath(root, abs)} (${id})`);
       }
     }
     return;
   }
-  const allAbsPaths = toRemove.flatMap(
-    ({ existing }) => existing.map((rel) => path19.join(root, rel))
-  );
+  const allAbsPaths = toRemove.flatMap(({ existing }) => existing.map(({ abs }) => abs));
   await backupBeforePrune(root, allAbsPaths, say);
   for (const { id, existing } of toRemove) {
-    for (const rel of existing) {
-      const abs = path19.join(root, rel);
+    for (const { abs } of existing) {
       await fs18.remove(abs);
-      await pruneEmptyDir(path19.dirname(abs));
+      await pruneEmptyDir(path20.dirname(abs));
       say(`Pruned orphaned ${displayPath(root, abs)} (${id})`);
     }
   }
@@ -3342,7 +3606,7 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
 
 // src/claude/write-gitignore.ts
 init_exec();
-import path20 from "node:path";
+import path21 from "node:path";
 import fs19 from "fs-extra";
 var GITIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var GITIGNORE_END = "# HAUS:END haus-managed";
@@ -3457,14 +3721,14 @@ function injectLinkContextGitignoreBlock(existing) {
   );
 }
 async function writeGitignore(root, dryRun) {
-  const filePath = path20.join(root, ".gitignore");
+  const filePath = path21.join(root, ".gitignore");
   const prev = await fs19.pathExists(filePath) ? await fs19.readFile(filePath, "utf8") : "";
   const next = injectGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun);
   return filePath;
 }
 async function writeLinkContextGitignore(root, dryRun) {
-  const filePath = path20.join(root, ".gitignore");
+  const filePath = path21.join(root, ".gitignore");
   const prev = await fs19.pathExists(filePath) ? await fs19.readFile(filePath, "utf8") : "";
   const next = injectLinkContextGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun);
@@ -3506,15 +3770,15 @@ async function untrackMachineLocalArtifacts(root, dryRun, notify) {
 }
 
 // src/refs/fetch-refs.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import fs21 from "fs-extra";
 
 // src/refs/cache-meta.ts
-import path21 from "node:path";
+import path22 from "node:path";
 import fs20 from "fs-extra";
 var META_FILENAME = "cache-meta.json";
 async function readCacheMeta(cacheDir) {
-  const metaPath = path21.join(cacheDir, META_FILENAME);
+  const metaPath = path22.join(cacheDir, META_FILENAME);
   try {
     const raw = await fs20.readFile(metaPath, "utf8");
     return JSON.parse(raw);
@@ -3524,7 +3788,7 @@ async function readCacheMeta(cacheDir) {
 }
 async function writeCacheMeta(cacheDir, meta) {
   await fs20.ensureDir(cacheDir);
-  const metaPath = path21.join(cacheDir, META_FILENAME);
+  const metaPath = path22.join(cacheDir, META_FILENAME);
   await fs20.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
 }
 
@@ -3545,8 +3809,8 @@ function isLlmsTxtUrl(ref) {
 async function fetchSingleRef(url, cacheDir, meta) {
   const existing = meta[url];
   const headers = {};
-  const safeFile = existing?.file && existing.file === path22.basename(existing.file);
-  const cachedFileExists = safeFile && await fs21.pathExists(path22.join(cacheDir, existing.file));
+  const safeFile = existing?.file && existing.file === path23.basename(existing.file);
+  const cachedFileExists = safeFile && await fs21.pathExists(path23.join(cacheDir, existing.file));
   if (cachedFileExists) {
     if (existing?.etag) headers["If-None-Match"] = existing.etag;
     if (existing?.lastModified) headers["If-Modified-Since"] = existing.lastModified;
@@ -3558,7 +3822,7 @@ async function fetchSingleRef(url, cacheDir, meta) {
     const text = await res.text();
     const file = `${urlToSlug(url)}.md`;
     await fs21.ensureDir(cacheDir);
-    await fs21.writeFile(path22.join(cacheDir, file), text, "utf8");
+    await fs21.writeFile(path23.join(cacheDir, file), text, "utf8");
     meta[url] = {
       url,
       etag: res.headers.get("etag") ?? void 0,
@@ -3581,8 +3845,8 @@ async function pruneOrphanedRefs(cacheDir, keepUrls) {
     if (keepUrls.has(url)) continue;
     delete meta[url];
     removed++;
-    const safeFile = typeof entry.file === "string" && entry.file === path22.basename(entry.file);
-    if (safeFile) await fs21.remove(path22.join(cacheDir, entry.file)).catch(() => {
+    const safeFile = typeof entry.file === "string" && entry.file === path23.basename(entry.file);
+    if (safeFile) await fs21.remove(path23.join(cacheDir, entry.file)).catch(() => {
     });
   }
   if (removed > 0) await writeCacheMeta(cacheDir, meta);
@@ -3604,10 +3868,10 @@ async function fetchRefsForItems(items, cacheDir) {
       const outcome = await fetchSingleRef(url, cacheDir, meta);
       if (outcome.result === "fetched") {
         summary.fetched++;
-        summary.cachedFiles[url] = path22.join(cacheDir, outcome.file);
+        summary.cachedFiles[url] = path23.join(cacheDir, outcome.file);
       } else if (outcome.result === "unchanged") {
         summary.unchanged++;
-        if (meta[url]?.file) summary.cachedFiles[url] = path22.join(cacheDir, meta[url].file);
+        if (meta[url]?.file) summary.cachedFiles[url] = path23.join(cacheDir, meta[url].file);
       } else {
         summary.failed++;
         summary.failedUrls.push(url);
@@ -3630,7 +3894,7 @@ function parseIdList(value) {
 // src/commands/apply.ts
 var STALE_CACHE_THRESHOLD_DAYS = 7;
 async function cacheHasItems() {
-  const data = await readJson(path23.join(getCacheDir(), "manifest.json"));
+  const data = await readJson(path24.join(getCacheDir(), "manifest.json"));
   return Array.isArray(data?.items) && data.items.length > 0;
 }
 function installableRecommendedItems(recommended) {
@@ -3781,7 +4045,7 @@ async function runApply(options) {
 }
 
 // src/commands/backups.ts
-import path24 from "node:path";
+import path25 from "node:path";
 import fs22 from "fs-extra";
 
 // src/utils/prompts.ts
@@ -3818,7 +4082,7 @@ async function listBackups(root) {
   for (const name of names) {
     const kind = classify(name);
     if (!kind) continue;
-    const absPath = path24.join(dir, name);
+    const absPath = path25.join(dir, name);
     const stat = await fs22.lstat(absPath);
     if (stat.isSymbolicLink()) continue;
     const expectDirectory = kind !== "lock";
@@ -3848,10 +4112,10 @@ async function runList(root) {
   }
 }
 async function isUnsafeWriteTarget(root, target) {
-  const segments = path24.relative(root, target).split(path24.sep).filter(Boolean);
+  const segments = path25.relative(root, target).split(path25.sep).filter(Boolean);
   let current = root;
   for (let i = 0; i < segments.length; i++) {
-    current = path24.join(current, segments[i]);
+    current = path25.join(current, segments[i]);
     const isLastSegment = i === segments.length - 1;
     try {
       const stat = await fs22.lstat(current);
@@ -3915,7 +4179,7 @@ async function collectFilesRecursive(dir) {
   const skippedOther = [];
   const names = await fs22.readdir(dir);
   for (const name of names) {
-    const abs = path24.join(dir, name);
+    const abs = path25.join(dir, name);
     const stat = await fs22.lstat(abs);
     if (stat.isSymbolicLink()) {
       skippedLinks.push(abs);
@@ -3938,12 +4202,12 @@ 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) => path24.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path25.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) => path24.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path25.relative(entry.absPath, abs)).join(", ")}`
     );
   }
   if (files.length === 0) {
@@ -3953,8 +4217,8 @@ async function restoreDirBackup(root, entry, yes) {
   const safeFiles = [];
   const unsafeTargets = [];
   for (const abs of files) {
-    const rel = path24.relative(entry.absPath, abs);
-    const target = path24.join(root, rel);
+    const rel = path25.relative(entry.absPath, abs);
+    const target = path25.join(root, rel);
     if (await isUnsafeWriteTarget(root, target)) unsafeTargets.push(rel);
     else safeFiles.push(abs);
   }
@@ -3971,14 +4235,14 @@ async function restoreDirBackup(root, entry, yes) {
   const vanished = [];
   const toRestore = [];
   for (const abs of safeFiles) {
-    const rel = path24.relative(entry.absPath, abs);
+    const rel = path25.relative(entry.absPath, abs);
     const backupFileStat = await lstatIfRegularFile(abs);
     if (!backupFileStat) {
       vanished.push(rel);
       continue;
     }
     toRestore.push(abs);
-    const target = path24.join(root, rel);
+    const target = path25.join(root, rel);
     if (await fs22.pathExists(target)) {
       const targetStat = await fs22.stat(target);
       if (targetStat.mtimeMs > backupFileStat.mtimeMs) {
@@ -4019,13 +4283,13 @@ async function restoreDirBackup(root, entry, yes) {
   let restoredCount = 0;
   const skippedAtWrite = [];
   for (const abs of toRestore) {
-    const rel = path24.relative(entry.absPath, abs);
-    const target = path24.join(root, rel);
+    const rel = path25.relative(entry.absPath, abs);
+    const target = path25.join(root, rel);
     if (!await lstatIfRegularFile(abs) || await isUnsafeWriteTarget(root, target)) {
       skippedAtWrite.push(rel);
       continue;
     }
-    await fs22.ensureDir(path24.dirname(target));
+    await fs22.ensureDir(path25.dirname(target));
     await fs22.copy(abs, target, { overwrite: true });
     restoredCount++;
   }
@@ -4164,16 +4428,53 @@ async function runCatalogAudit() {
 }
 
 // src/commands/doctor.ts
-import path38 from "node:path";
-import fs29 from "fs-extra";
+import path39 from "node:path";
+import fs30 from "fs-extra";
+
+// src/claude/skill-reference-check.ts
+import path26 from "node:path";
+import fg4 from "fast-glob";
+import fs23 from "fs-extra";
+var REFERENCE_PATTERN = /\b([a-z][a-z0-9]*(?:-[a-z0-9]+)+):([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\b(?!:\/\/)/g;
+function stripFencedCodeBlocks(text) {
+  return text.replace(/```[\s\S]*?```/g, (block) => block.replace(/[^\n]/g, " "));
+}
+async function findUnresolvedSkillReferences(root) {
+  const skillsRoot = claudePath(root, "skills");
+  if (!await fs23.pathExists(skillsRoot)) return [];
+  const skillDirs = (await fs23.readdir(skillsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== "shared").map((entry) => entry.name);
+  const installedSkillNames = new Set(skillDirs);
+  const files = await fg4("*/**/*.md", { cwd: skillsRoot, onlyFiles: true, dot: true });
+  const issues = [];
+  for (const rel of files) {
+    if (rel.startsWith("shared/")) continue;
+    const abs = path26.join(skillsRoot, rel);
+    const raw = await fs23.readFile(abs, "utf8");
+    const lines = stripFencedCodeBlocks(raw).split("\n");
+    lines.forEach((line2, idx) => {
+      for (const match of line2.matchAll(REFERENCE_PATTERN)) {
+        const [reference, , bareName] = match;
+        if (!reference || !bareName) continue;
+        issues.push({
+          file: path26.join(".claude/skills", rel),
+          line: idx + 1,
+          reference,
+          bareName,
+          bareInstalled: installedSkillNames.has(bareName)
+        });
+      }
+    });
+  }
+  return issues;
+}
 
 // src/decisions/doctor.ts
-import path29 from "node:path";
-import fs26 from "fs-extra";
+import path31 from "node:path";
+import fs27 from "fs-extra";
 
 // src/decisions/check.ts
-import path28 from "node:path";
-import fs25 from "fs-extra";
+import path30 from "node:path";
+import fs26 from "fs-extra";
 
 // src/decisions/dep-bump.ts
 var DEP_SECTIONS = [
@@ -4182,15 +4483,15 @@ var DEP_SECTIONS = [
   "peerDependencies",
   "optionalDependencies"
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function extractDepMap(pkg) {
   const map = /* @__PURE__ */ new Map();
-  if (!isRecord(pkg)) return map;
+  if (!isRecord2(pkg)) return map;
   for (const section of DEP_SECTIONS) {
     const block = pkg[section];
-    if (!isRecord(block)) continue;
+    if (!isRecord2(block)) continue;
     for (const [name, ver] of Object.entries(block)) {
       if (typeof ver === "string") map.set(`${section}:${name}`, ver);
     }
@@ -4216,7 +4517,7 @@ function isDependencyBumpOnly(beforeText, afterText) {
   } catch {
     return false;
   }
-  if (!isRecord(before) || !isRecord(after)) return false;
+  if (!isRecord2(before) || !isRecord2(after)) return false;
   const beforeDeps = extractDepMap(before);
   const afterDeps = extractDepMap(after);
   if (beforeDeps.size === 0 && afterDeps.size === 0) return false;
@@ -4232,7 +4533,7 @@ function isDependencyBumpOnly(beforeText, afterText) {
 
 // src/decisions/diff.ts
 init_exec();
-import path25 from "node:path";
+import path27 from "node:path";
 function isPackageJsonPath(file) {
   return file === "package.json" || file.endsWith("/package.json");
 }
@@ -4259,6 +4560,11 @@ function parseDiffRange(range) {
   }
   return null;
 }
+function toAncestryLogRange(range) {
+  const parsed = parseDiffRange(range);
+  if (!parsed) return `${range}..HEAD`;
+  return `${parsed.left}..${parsed.right}`;
+}
 async function getCurrentBranch(root) {
   const result = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: root });
   if (result.exitCode !== 0) return void 0;
@@ -4288,7 +4594,7 @@ async function resolvePackageJsonPair(root, file, opts) {
     return { before: before2, after: after2 };
   }
   const before = await readBlob(root, `${range}:${file}`) ?? empty;
-  const after = await readText(path25.join(root, file)) ?? empty;
+  const after = await readText(path27.join(root, file)) ?? empty;
   return { before, after };
 }
 async function collectDiffStats(root, opts) {
@@ -4359,22 +4665,22 @@ function firstMatchingRegex(filePath, patterns) {
 }
 
 // src/decisions/paths.ts
-import path26 from "node:path";
-import fs23 from "fs-extra";
+import path28 from "node:path";
+import fs24 from "fs-extra";
 async function resolveDecisionsDir(root) {
-  const primary = path26.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  if (await fs23.pathExists(primary)) return primary;
-  const legacy = path26.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  if (await fs23.pathExists(legacy)) return legacy;
+  const primary = path28.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  if (await fs24.pathExists(primary)) return primary;
+  const legacy = path28.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  if (await fs24.pathExists(legacy)) return legacy;
   return primary;
 }
 function relativeDecisionPath(decisionsDir, root) {
-  return path26.relative(root, decisionsDir).replace(/\\/g, "/");
+  return path28.relative(root, decisionsDir).replace(/\\/g, "/");
 }
 
 // src/decisions/validate.ts
-import path27 from "node:path";
-import fs24 from "fs-extra";
+import path29 from "node:path";
+import fs25 from "fs-extra";
 function validateDecisionContent(content2) {
   const errors = [];
   for (const section of DECISIONS_TRIGGERS.requiredSections) {
@@ -4403,14 +4709,14 @@ function decisionNumberFromFile(name) {
   return match?.[1] ?? null;
 }
 async function validateIndexSync(decisionsDir, decisionFiles) {
-  const readmePath = path27.join(decisionsDir, "README.md");
-  if (!await fs24.pathExists(readmePath)) {
+  const readmePath = path29.join(decisionsDir, "README.md");
+  if (!await fs25.pathExists(readmePath)) {
     return ["docs/decisions/README.md is missing"];
   }
   const readme = await readText(readmePath) ?? "";
   const errors = [];
   for (const file of decisionFiles) {
-    const num = decisionNumberFromFile(path27.basename(file));
+    const num = decisionNumberFromFile(path29.basename(file));
     if (num && !indexReferencesNumber(readme, num)) {
       errors.push(`README.md missing index row for ADR-${num}`);
     }
@@ -4505,22 +4811,22 @@ async function checkSatisfaction(input2) {
   const errors = [];
   const decisionsPrefix = `${input2.decisionsRel}/`;
   const newDecisionFiles = input2.changedFiles.filter(
-    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path28.basename(f))
+    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path30.basename(f))
   );
   if (newDecisionFiles.length === 0) {
     errors.push(`no new or updated decision under ${input2.decisionsRel}/`);
     return errors;
   }
-  const decisionsDir = path28.join(input2.root, input2.decisionsRel);
+  const decisionsDir = path30.join(input2.root, input2.decisionsRel);
   for (const rel of newDecisionFiles) {
-    const abs = path28.join(input2.root, rel);
+    const abs = path30.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) => path28.basename(f))
+    newDecisionFiles.map((f) => path30.basename(f))
   );
   errors.push(...indexErrors);
   return errors;
@@ -4576,8 +4882,8 @@ ${opts.commitMessages ?? ""}`;
     changedFiles: stats.files
   });
   if (satisfactionErrors.length > 0 && decisionsRel !== legacyRel) {
-    const legacyExists = await fs25.pathExists(path28.join(root, legacyRel));
-    if (legacyExists && !await fs25.pathExists(decisionsDir)) {
+    const legacyExists = await fs26.pathExists(path30.join(root, legacyRel));
+    if (legacyExists && !await fs26.pathExists(decisionsDir)) {
       satisfactionErrors = await checkSatisfaction({
         root,
         decisionsRel: legacyRel,
@@ -4599,18 +4905,18 @@ ${opts.commitMessages ?? ""}`;
   return { triggered: true, satisfied: false, reasons, securityTriggered };
 }
 async function listDecisionNumbers(decisionsDir) {
-  if (!await fs25.pathExists(decisionsDir)) return [];
-  const entries = await fs25.readdir(decisionsDir);
+  if (!await fs26.pathExists(decisionsDir)) return [];
+  const entries = await fs26.readdir(decisionsDir);
   return entries.map((name) => decisionNumberFromFile(name)).filter((n) => n != null).map((n) => Number(n));
 }
 
 // src/decisions/doctor.ts
 async function auditDecisionsLayout(root) {
   const findings = [];
-  const primary = path29.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const legacy = path29.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  const hasPrimary = await fs26.pathExists(primary);
-  const hasLegacy = await fs26.pathExists(legacy);
+  const primary = path31.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const legacy = path31.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  const hasPrimary = await fs27.pathExists(primary);
+  const hasLegacy = await fs27.pathExists(legacy);
   if (!hasPrimary && hasLegacy) {
     findings.push({
       level: "advisory",
@@ -4623,8 +4929,8 @@ async function auditDecisionsLayout(root) {
   if (!hasPrimary) return findings;
   const decisionsDir = await resolveDecisionsDir(root);
   const rel = relativeDecisionPath(decisionsDir, root);
-  const readmePath = path29.join(decisionsDir, "README.md");
-  if (!await fs26.pathExists(readmePath)) {
+  const readmePath = path31.join(decisionsDir, "README.md");
+  if (!await fs27.pathExists(readmePath)) {
     findings.push({
       level: "advisory",
       line: `- DECISIONS: missing ${rel}/README.md index`,
@@ -4634,7 +4940,7 @@ async function auditDecisionsLayout(root) {
     return findings;
   }
   const readme = await readText(readmePath);
-  const entries = (await fs26.readdir(decisionsDir)).filter(
+  const entries = (await fs27.readdir(decisionsDir)).filter(
     (f) => f.endsWith(".md") && f !== "README.md"
   );
   for (const file of entries) {
@@ -4648,7 +4954,7 @@ async function auditDecisionsLayout(root) {
       });
     }
   }
-  const claude = await readText(path29.join(root, "CLAUDE.md"));
+  const claude = await readText(path31.join(root, "CLAUDE.md"));
   if (claude && !claude.includes(`@${rel}/README.md`)) {
     findings.push({
       level: "advisory",
@@ -4679,11 +4985,11 @@ async function auditDecisionsLayout(root) {
 }
 
 // src/scanner/read-context.ts
-import path37 from "node:path";
-import fs28 from "fs-extra";
+import path38 from "node:path";
+import fs29 from "fs-extra";
 
 // src/commands/workspace/config.ts
-import path30 from "node:path";
+import path32 from "node:path";
 import YAML from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
@@ -4706,11 +5012,11 @@ function parseWorkspaceConfig(text) {
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
-  return parseWorkspaceConfig(await readText(path30.join(workspaceRoot, WORKSPACE_FILE)));
+  return parseWorkspaceConfig(await readText(path32.join(workspaceRoot, WORKSPACE_FILE)));
 }
 
 // src/workspace/members.ts
-import path31 from "node:path";
+import path33 from "node:path";
 var REPOS_MANIFEST_FILE = "repos.manifest.json";
 var REPOS_LOCAL_FILE = "repos.local.json";
 var MemberConfigError = class extends Error {
@@ -4723,14 +5029,14 @@ var MemberConfigError = class extends Error {
 };
 function resolveAbsPath(workspaceRoot, folder, overrides) {
   const override = overrides[folder];
-  if (override) return path31.resolve(workspaceRoot, override);
-  return path31.resolve(workspaceRoot, folder);
+  if (override) return path33.resolve(workspaceRoot, override);
+  return path33.resolve(workspaceRoot, folder);
 }
 function isSelfMember(workspaceRoot, member) {
-  return path31.resolve(member.absPath) === path31.resolve(workspaceRoot);
+  return path33.resolve(member.absPath) === path33.resolve(workspaceRoot);
 }
 async function readPathOverrides(workspaceRoot) {
-  const filePath = path31.join(workspaceRoot, REPOS_LOCAL_FILE);
+  const filePath = path33.join(workspaceRoot, REPOS_LOCAL_FILE);
   const result = await readJsonDetailed(filePath);
   if (result.status === "missing") return {};
   if (result.status === "invalid") throw new MemberConfigError(filePath, "invalid JSON");
@@ -4746,7 +5052,7 @@ async function readPathOverrides(workspaceRoot) {
   return overrides;
 }
 async function readFromWorkspaceYaml(workspaceRoot, overrides) {
-  const filePath = path31.join(workspaceRoot, WORKSPACE_FILE);
+  const filePath = path33.join(workspaceRoot, WORKSPACE_FILE);
   const text = await readText(filePath);
   if (text === void 0) return void 0;
   const config = parseWorkspaceConfig(text);
@@ -4759,7 +5065,7 @@ async function readFromWorkspaceYaml(workspaceRoot, overrides) {
   }));
 }
 async function readFromManifest(workspaceRoot, overrides) {
-  const filePath = path31.join(workspaceRoot, REPOS_MANIFEST_FILE);
+  const filePath = path33.join(workspaceRoot, REPOS_MANIFEST_FILE);
   const result = await readJsonDetailed(filePath);
   if (result.status === "missing") return void 0;
   if (result.status === "invalid") throw new MemberConfigError(filePath, "invalid JSON");
@@ -4801,16 +5107,11 @@ async function readMembers(rootInfo) {
 }
 
 // src/scanner/scan-project.ts
-import path36 from "node:path";
-
-// src/utils/audit-checks.ts
-function isRecord2(v) {
-  return typeof v === "object" && v !== null;
-}
+import path37 from "node:path";
 
 // src/utils/git-root.ts
 init_exec();
-import path32 from "node:path";
+import path34 from "node:path";
 function fallback(start) {
   return {
     cwd: start,
@@ -4826,11 +5127,11 @@ function fallback(start) {
 async function resolveAbsoluteGitPath(flag, cwd, repoRoot) {
   const withFormat = await runGit(["rev-parse", "--path-format=absolute", flag], { cwd });
   const raw = withFormat.exitCode === 0 ? withFormat.stdout.trim() : "";
-  if (raw && path32.isAbsolute(raw)) return path32.resolve(raw);
+  if (raw && path34.isAbsolute(raw)) return path34.resolve(raw);
   const plain = await runGit(["rev-parse", flag], { cwd });
   const plainRaw = plain.exitCode === 0 ? plain.stdout.trim() : "";
   if (!plainRaw) return "";
-  return path32.isAbsolute(plainRaw) ? path32.resolve(plainRaw) : path32.resolve(repoRoot, plainRaw);
+  return path34.isAbsolute(plainRaw) ? path34.resolve(plainRaw) : path34.resolve(repoRoot, plainRaw);
 }
 async function resolveRoots(start) {
   const cwd = start ?? process.cwd();
@@ -4839,15 +5140,15 @@ async function resolveRoots(start) {
     if (toplevel.exitCode !== 0) return fallback(cwd);
     const toplevelRaw = toplevel.stdout.trim();
     if (!toplevelRaw) return fallback(cwd);
-    const repoRoot = path32.resolve(toplevelRaw);
+    const repoRoot = path34.resolve(toplevelRaw);
     const [gitDir, gitCommonDir] = await Promise.all([
       resolveAbsoluteGitPath("--git-dir", cwd, repoRoot),
       resolveAbsoluteGitPath("--git-common-dir", cwd, repoRoot)
     ]);
     if (!gitDir || !gitCommonDir) return fallback(cwd);
     const isLinkedWorktree = gitDir !== gitCommonDir;
-    const mainRoot = isLinkedWorktree && path32.basename(gitCommonDir) === ".git" ? path32.dirname(gitCommonDir) : repoRoot;
-    const worktreeName = isLinkedWorktree ? path32.basename(gitDir) : null;
+    const mainRoot = isLinkedWorktree && path34.basename(gitCommonDir) === ".git" ? path34.dirname(gitCommonDir) : repoRoot;
+    const worktreeName = isLinkedWorktree ? path34.basename(gitDir) : null;
     return {
       cwd,
       repoRoot,
@@ -4892,8 +5193,8 @@ function resolveMajorVersion(range) {
 }
 
 // src/scanner/detect-package-manager.ts
-import path33 from "node:path";
-import fs27 from "fs-extra";
+import path35 from "node:path";
+import fs28 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -4911,9 +5212,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs27.existsSync(path33.join(root, "yarn.lock"))) return "yarn";
-  if (fs27.existsSync(path33.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs27.existsSync(path33.join(root, "package-lock.json"))) return "npm";
+  if (fs28.existsSync(path35.join(root, "yarn.lock"))) return "yarn";
+  if (fs28.existsSync(path35.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs28.existsSync(path35.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
@@ -5030,6 +5331,7 @@ var STACK_RULES = [
     stack: ["frontend", "shadcn"],
     all: [fileEndsWith("components.json"), dep("class-variance-authority")]
   },
+  { stack: ["frontend", "radix"], any: [depPrefix("@radix-ui/")] },
   { stack: ["tooling", "typescript5"], any: [depMajor("typescript", 5)] },
   { stack: ["backend", "sanity"], any: [dep("sanity"), dep("next-sanity"), dep("@sanity/client")] },
   { stack: ["backend", "strapi"], any: [dep("@strapi/strapi"), depPrefix("@strapi/")] },
@@ -5100,114 +5402,44 @@ var STACK_RULES = [
   { stack: ["testing", "playwright"], any: [dep("@playwright/test")] },
   { stack: ["testing", "storybook"], any: [fileIncludes(".storybook")] },
   { stack: ["testing", "testing-library"], any: [depPrefix("@testing-library/")] },
-  { stack: ["testing", "phpunit"], any: [fileEndsWith("phpunit.xml")] },
-  { stack: ["testing", "storybook"], any: [depPrefix("@storybook/")] },
-  { stack: ["testing", "vitest"], any: [dep("vitest")] },
-  { stack: ["testing", "jest"], any: [dep("jest"), dep("jest-environment-jsdom")] },
-  { stack: ["databases", "postgresql"], any: [dep("pg")] },
-  { stack: ["databases", "mariadb"], any: [dep("mariadb"), dep("mysql2")] },
-  { stack: ["databases", "mysql"], any: [dep("mysql"), dep("mysql2")] },
-  { stack: ["databases", "mssql"], any: [dep("mssql")] },
-  { stack: ["databases", "elasticsearch"], any: [dep("@elastic/elasticsearch")] },
-  { stack: ["databases", "redis"], any: [dep("predis/predis"), dep("ioredis"), dep("redis")] },
-  { stack: ["auth", "oidc"], any: [content("openid")] },
-  { stack: ["auth", "azure-ad"], any: [content("AZURE_AD")] },
-  { stack: ["auth", "bankid"], any: [content("BANKID")] },
-  {
-    stack: ["auth", "saml2"],
-    any: [dep("24slides/laravel-saml2"), dep("aacotroneo/laravel-saml2")]
-  },
-  { stack: ["auth", "next-auth"], any: [dep("next-auth"), dep("@auth/core")] }
-];
-function runDetection(ctx, rules = STACK_RULES) {
-  const roles = [];
-  for (const rule of ROLE_RULES) {
-    if (rule.role && matchRule(rule, ctx) && !roles.includes(rule.role)) roles.push(rule.role);
-  }
-  const stacks = {};
-  for (const bucket of STACK_BUCKETS) stacks[bucket] = [];
-  for (const rule of rules) {
-    if (!rule.stack || !matchRule(rule, ctx)) continue;
-    const [bucket, name] = rule.stack;
-    stacks[bucket] ??= [];
-    if (!stacks[bucket].includes(name)) stacks[bucket].push(name);
-  }
-  return { roles, stacks };
-}
-
-// src/scanner/detection.ts
-import path34 from "node:path";
-var UNSUPPORTED_MARKERS = {
-  "requirements.txt": "python",
-  "pyproject.toml": "python",
-  "go.mod": "go",
-  "Cargo.toml": "rust",
-  "pom.xml": "java",
-  "build.gradle": "java",
-  "build.gradle.kts": "java",
-  Gemfile: "ruby"
-};
-var WEAK_STACK_SIGNALS = /* @__PURE__ */ new Set(["missing-prettier", "missing-eslint"]);
-function computeDetectionStatus(roles, stacks, unsupportedSignals) {
-  const hasRealStack = Object.entries(stacks).some(
-    ([bucket, names]) => bucket !== "packageManagers" && names.some((n) => !WEAK_STACK_SIGNALS.has(n))
-  );
-  const hasRealSignal = roles.length > 0 || hasRealStack;
-  if (!hasRealSignal) return "unknown";
-  return unsupportedSignals.length > 0 ? "partial" : "supported";
-}
-function describeUnknownDetection(unsupportedSignals, isLinkedWorktree) {
-  const markers = unsupportedSignals.join(", ");
-  const base = markers ? `Stack not recognised \u2014 detected ${markers}, which haus does not support.` : "Stack not recognised \u2014 no supported framework detected.";
-  const worktreeNote = isLinkedWorktree ? "You're running from inside a git worktree \u2014 sibling repos may not be on disk here, so this could be a false zero-signal reading rather than truly no stack." : "";
-  return [base, worktreeNote, "Only stack-agnostic workflow and security guidance is applied."].filter(Boolean).join(" ");
-}
-function blocked(rel) {
-  return SENSITIVE_PATH_REGEXES.some((x) => x.test(rel));
-}
-function dependencyVersionMap(pkg, composer) {
-  const versions = /* @__PURE__ */ new Map();
-  const pushObj = (obj) => {
-    if (!isRecord2(obj)) return;
-    for (const key of Object.keys(obj)) {
-      if (versions.has(key)) continue;
-      const value = obj[key];
-      versions.set(key, typeof value === "string" ? value : "");
-    }
-  };
-  pushObj(pkg?.dependencies);
-  pushObj(pkg?.devDependencies);
-  pushObj(composer?.require);
-  pushObj(composer?.["require-dev"]);
-  return versions;
-}
-function finalizeRoles(registryRoles, deps, files) {
-  const roles = new Set(registryRoles);
-  const hasWpConfig = files.some((f) => f.endsWith("wp-config.php"));
-  const hasBedrockLayout = files.some((f) => f.includes("web/app")) || deps.includes("roots/wordpress");
-  if (hasWpConfig && hasBedrockLayout) {
-    roles.add("wordpress-bedrock-site");
-    roles.add("wordpress-site");
-  } else if (hasWpConfig) {
-    roles.add("wordpress-vanilla-site");
-    roles.add("wordpress-site");
-  } else if (deps.includes("roots/wordpress")) {
-    roles.add("wordpress-bedrock-site");
-    roles.add("wordpress-site");
+  { stack: ["testing", "phpunit"], any: [fileEndsWith("phpunit.xml")] },
+  { stack: ["testing", "storybook"], any: [depPrefix("@storybook/")] },
+  { stack: ["testing", "vitest"], any: [dep("vitest")] },
+  { stack: ["testing", "jest"], any: [dep("jest"), dep("jest-environment-jsdom")] },
+  { stack: ["databases", "postgresql"], any: [dep("pg")] },
+  { stack: ["databases", "mariadb"], any: [dep("mariadb"), dep("mysql2")] },
+  { stack: ["databases", "mysql"], any: [dep("mysql"), dep("mysql2")] },
+  { stack: ["databases", "mssql"], any: [dep("mssql")] },
+  { stack: ["databases", "elasticsearch"], any: [dep("@elastic/elasticsearch")] },
+  { stack: ["databases", "redis"], any: [dep("predis/predis"), dep("ioredis"), dep("redis")] },
+  { stack: ["auth", "oidc"], any: [content("openid")] },
+  { stack: ["auth", "azure-ad"], any: [content("AZURE_AD")] },
+  { stack: ["auth", "bankid"], any: [content("BANKID")] },
+  {
+    stack: ["auth", "saml2"],
+    any: [dep("24slides/laravel-saml2"), dep("aacotroneo/laravel-saml2")]
+  },
+  { stack: ["auth", "next-auth"], any: [dep("next-auth"), dep("@auth/core")] }
+];
+function runDetection(ctx, rules = STACK_RULES) {
+  const roles = [];
+  for (const rule of ROLE_RULES) {
+    if (rule.role && matchRule(rule, ctx) && !roles.includes(rule.role)) roles.push(rule.role);
   }
-  return [...roles].sort();
-}
-function collectUnsupportedSignals(files) {
-  return [
-    ...new Set(
-      files.map((f) => UNSUPPORTED_MARKERS[path34.basename(f)]).filter((s) => Boolean(s))
-    )
-  ].sort();
+  const stacks = {};
+  for (const bucket of STACK_BUCKETS) stacks[bucket] = [];
+  for (const rule of rules) {
+    if (!rule.stack || !matchRule(rule, ctx)) continue;
+    const [bucket, name] = rule.stack;
+    stacks[bucket] ??= [];
+    if (!stacks[bucket].includes(name)) stacks[bucket].push(name);
+  }
+  return { roles, stacks };
 }
 
 // src/scanner/render.ts
 import { readFile } from "node:fs/promises";
-import path35 from "node:path";
+import path36 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")
@@ -5215,7 +5447,7 @@ async function buildContentBlob(root, files) {
   const slice = candidates.slice(0, 300);
   const parts = await mapWithConcurrency(slice, async (rel) => {
     try {
-      return await readFile(path35.join(root, rel), "utf8");
+      return await readFile(path36.join(root, rel), "utf8");
     } catch {
       return "";
     }
@@ -5307,8 +5539,8 @@ var SAFE_FILES = [
   "Gemfile"
 ];
 async function scanProject(root) {
-  const pkg = await readJson(path36.join(root, "package.json"));
-  const composer = await readJson(path36.join(root, "composer.json"));
+  const pkg = await readJson(path37.join(root, "package.json"));
+  const composer = await readJson(path37.join(root, "composer.json"));
   const files = await listFiles(root, SAFE_FILES);
   const safeFiles = files.filter((f) => !blocked(f));
   const depVersions = dependencyVersionMap(pkg, composer);
@@ -5328,7 +5560,7 @@ async function scanProject(root) {
   const warnings = [];
   const securityRisks = [];
   const crossRepoHints = [];
-  const nodeEngine = isRecord2(pkg?.engines) ? String(pkg.engines.node ?? "") : "";
+  const nodeEngine = isRecord(pkg?.engines) ? String(pkg.engines.node ?? "") : "";
   if (nodeEngine && !satisfiesVersion(process.version, nodeEngine)) {
     warnings.push(`Current Node ${process.version} does not satisfy package engine ${nodeEngine}`);
   }
@@ -5338,7 +5570,7 @@ async function scanProject(root) {
     crossRepoHints.push("Monorepo orchestration detected");
   const unsupportedSignals = collectUnsupportedSignals(safeFiles);
   const detectionStatus = computeDetectionStatus(roles, stacks, unsupportedSignals);
-  const repoNameFallback = pkg?.name ? String(pkg.name) : path36.basename((await resolveRoots(root)).mainRoot);
+  const repoNameFallback = pkg?.name ? String(pkg.name) : path37.basename((await resolveRoots(root)).mainRoot);
   const context = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     repoName: repoNameFallback,
@@ -5360,14 +5592,15 @@ async function scanProject(root) {
 // src/scanner/read-context.ts
 async function isCacheFresh(root, cachePath) {
   const markerPaths = [
-    path37.join(root, "package.json"),
-    path37.join(root, WORKSPACE_FILE),
-    path37.join(root, REPOS_MANIFEST_FILE)
+    path38.join(root, "package.json"),
+    path38.join(root, "composer.json"),
+    path38.join(root, WORKSPACE_FILE),
+    path38.join(root, REPOS_MANIFEST_FILE)
   ];
-  const cacheStat = await fs28.stat(cachePath);
+  const cacheStat = await fs29.stat(cachePath);
   for (const markerPath of markerPaths) {
-    if (!await fs28.pathExists(markerPath)) continue;
-    const markerStat = await fs28.stat(markerPath);
+    if (!await fs29.pathExists(markerPath)) continue;
+    const markerStat = await fs29.stat(markerPath);
     if (markerStat.mtimeMs > cacheStat.mtimeMs) return false;
   }
   return true;
@@ -5468,7 +5701,7 @@ async function runDoctor(options) {
   } else {
     ok(`- HOOKS OK: ${hooks.message}`);
   }
-  const rootClaudeMdPath = path38.join(root, "CLAUDE.md");
+  const rootClaudeMdPath = path39.join(root, "CLAUDE.md");
   const rootClaudeMdContent = await readText(rootClaudeMdPath);
   if (!rootClaudeMdContent) {
     flag(
@@ -5511,10 +5744,10 @@ async function runDoctor(options) {
         ok("- CLAUDE.md: import block present");
       }
       for (const target of actualTargets) {
-        const resolved = path38.resolve(root, target);
-        const relFromRoot = path38.relative(root, resolved);
-        const escapesRoot = relFromRoot === ".." || relFromRoot.startsWith(`..${path38.sep}`) || path38.isAbsolute(relFromRoot);
-        if (escapesRoot || !await fs29.pathExists(resolved)) {
+        const resolved = path39.resolve(root, target);
+        const relFromRoot = path39.relative(root, resolved);
+        const escapesRoot = relFromRoot === ".." || relFromRoot.startsWith(`..${path39.sep}`) || path39.isAbsolute(relFromRoot);
+        if (escapesRoot || !await fs30.pathExists(resolved)) {
           flag(
             `- CLAUDE.md import: @${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`,
@@ -5532,7 +5765,7 @@ async function runDoctor(options) {
     );
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs29.pathExists(workflowPath);
+  const workflowExists = await fs30.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -5547,15 +5780,15 @@ async function runDoctor(options) {
     } else {
       const storedHashMatch = firstLine.match(/hash=(sha256-[a-f0-9]+)/);
       const bodyContent = workflowContent.slice(firstLine.length + 1);
-      const cachePath = path38.join(getCacheDir(), "templates/agentic-workflow-standard.md");
-      const bundledPath = path38.join(
+      const cachePath = path39.join(getCacheDir(), "templates/agentic-workflow-standard.md");
+      const bundledPath = path39.join(
         packageRoot(),
         "library",
         "global",
         "templates",
         "agentic-workflow-standard.md"
       );
-      const templatePath = await fs29.pathExists(cachePath) ? cachePath : bundledPath;
+      const templatePath = await fs30.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") {
@@ -5576,7 +5809,7 @@ async function runDoctor(options) {
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs29.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs30.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -5584,7 +5817,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs29.readFile(workflowConfigPath, "utf8");
+    const cfg = await fs30.readFile(workflowConfigPath, "utf8");
     const unfilled = cfg.split("\n").filter((l) => l.includes("<!-- fill in")).length;
     if (unfilled > 0) {
       suggest(
@@ -5597,7 +5830,7 @@ async function runDoctor(options) {
     }
   }
   if (workflowExists) {
-    const prettierIgnore = await readText(path38.join(root, ".prettierignore")) ?? "";
+    const prettierIgnore = await readText(path39.join(root, ".prettierignore")) ?? "";
     const lines = prettierIgnore.split("\n");
     const missing = IGNORED_PATHS.filter((p) => !prettierIgnoreProtects(lines, p));
     if (missing.length > 0) {
@@ -5637,6 +5870,29 @@ async function runDoctor(options) {
     if (finding.level === "ok") ok(finding.line);
     else suggest(finding.line, finding.sentence, finding.fix);
   }
+  const skillRefIssues = await findUnresolvedSkillReferences(root);
+  if (skillRefIssues.length > 0) {
+    const prefixBug = skillRefIssues.filter((i) => i.bareInstalled);
+    const missingDep = skillRefIssues.filter((i) => !i.bareInstalled);
+    const describe = (i) => `${i.file}:${i.line} "${i.reference}"`;
+    if (prefixBug.length > 0) {
+      flag(
+        `- SKILL REFS: ${prefixBug.length} reference(s) use an unresolvable plugin-namespace prefix, though the target skill IS installed (${prefixBug.slice(0, 3).map(describe).join("; ")}${prefixBug.length > 3 ? "; \u2026" : ""})`,
+        `${prefixBug.length} skill reference(s) use a prefix that can't resolve, even though the target skill is installed`,
+        "haus apply --write (re-vendors the skill body with the prefix stripped)"
+      );
+    }
+    if (missingDep.length > 0) {
+      const missingNames = [...new Set(missingDep.map((i) => i.bareName))];
+      flag(
+        `- SKILL REFS: ${missingDep.length} reference(s) point at a skill that is not installed (${missingNames.join(", ")}) (${missingDep.slice(0, 3).map(describe).join("; ")}${missingDep.length > 3 ? "; \u2026" : ""})`,
+        `${missingDep.length} skill reference(s) point at a sub-skill (${missingNames.join(", ")}) that isn't installed`,
+        "find its catalog id and run `haus recommend --include <id>` then `haus apply --write`, or remove the reference"
+      );
+    }
+  } else {
+    ok("- SKILL REFS: OK (no unresolved cross-skill references)");
+  }
   const cacheAgeMs = await getCacheManifestAge();
   if (cacheAgeMs === null) {
     suggest(
@@ -5657,20 +5913,28 @@ async function runDoctor(options) {
     }
   }
   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) {
+    if (!Array.isArray(recommendation.recommended)) {
       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"
+        `- CATALOG ITEMS: recommendation.json's "recommended" field is not an array \u2014 skipping orphaned-item check`,
+        'recommendation.json looks malformed (its "recommended" field is not an array)',
+        "run `haus recommend` to regenerate it"
+      );
+    } else {
+      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(path38.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path39.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -5703,12 +5967,12 @@ async function runDoctor(options) {
 }
 
 // src/commands/update.ts
-import path41 from "node:path";
+import path42 from "node:path";
 
 // src/claude/refresh-project.ts
-import fs30 from "fs-extra";
+import fs31 from "fs-extra";
 async function isHausProject(root) {
-  if (await fs30.pathExists(hausPath(root, "recommendation.json"))) return true;
+  if (await fs31.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;
@@ -5720,8 +5984,8 @@ async function refreshProjectApply(root) {
 
 // src/install/apply.ts
 import crypto2 from "node:crypto";
-import path39 from "node:path";
-import fs31 from "fs-extra";
+import path40 from "node:path";
+import fs32 from "fs-extra";
 
 // src/install/header.ts
 var MD_PREFIX = "<!-- HAUS-MANAGED";
@@ -5805,59 +6069,66 @@ var SCHEMA_VERSION2 = "1";
 function hashContent(content2) {
   return `sha256-${crypto2.createHash("sha256").update(normaliseLF(content2)).digest("hex")}`;
 }
+function destFileMissing(destPath) {
+  try {
+    return !fs32.statSync(destPath).isFile();
+  } catch {
+    return true;
+  }
+}
 function sourceVersion() {
   try {
-    const pkgPath = path39.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path40.join(packageRoot(), "package.json");
+    const pkg = JSON.parse(fs32.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
   }
 }
 function globalSrcDir() {
-  return path39.join(packageRoot(), "library", "global");
+  return path40.join(packageRoot(), "library", "global");
 }
 function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
-  const skillDir = path39.join(skillsDir, skillName);
+  const skillDir = path40.join(skillsDir, skillName);
   const entries = [];
-  for (const rel of fs31.readdirSync(skillDir, { recursive: true })) {
+  for (const rel of fs32.readdirSync(skillDir, { recursive: true })) {
     if (rel === "SKILL.md") continue;
-    const abs = path39.join(skillDir, rel);
-    if (!fs31.statSync(abs).isFile()) continue;
-    const posixRel = rel.split(path39.sep).join("/");
+    const abs = path40.join(skillDir, rel);
+    if (!fs32.statSync(abs).isFile()) continue;
+    const posixRel = rel.split(path40.sep).join("/");
     entries.push({
       stableId: `skill.${skillName}.${posixRel.replace(/\//g, ".")}`,
-      srcRelPath: path39.join("library", "global", "skills", skillName, rel),
-      destPath: path39.join(claudeDir, "skills", skillName, rel)
+      srcRelPath: path40.join("library", "global", "skills", skillName, rel),
+      destPath: path40.join(claudeDir, "skills", skillName, rel)
     });
   }
   return entries;
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  const skillsDir = path39.join(srcDir, "skills");
-  if (fs31.pathExistsSync(skillsDir)) {
-    for (const skillName of fs31.readdirSync(skillsDir)) {
-      const skillFile = path39.join(skillsDir, skillName, "SKILL.md");
-      if (fs31.pathExistsSync(skillFile)) {
+  const skillsDir = path40.join(srcDir, "skills");
+  if (fs32.pathExistsSync(skillsDir)) {
+    for (const skillName of fs32.readdirSync(skillsDir)) {
+      const skillFile = path40.join(skillsDir, skillName, "SKILL.md");
+      if (fs32.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path39.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path39.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path40.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path40.join(claudeDir, "skills", skillName, "SKILL.md")
         });
         entries.push(...collectSkillAuxFiles(skillsDir, claudeDir, skillName));
       }
     }
   }
-  const commandsDir = path39.join(srcDir, "commands");
-  if (fs31.pathExistsSync(commandsDir)) {
-    for (const fileName of fs31.readdirSync(commandsDir)) {
+  const commandsDir = path40.join(srcDir, "commands");
+  if (fs32.pathExistsSync(commandsDir)) {
+    for (const fileName of fs32.readdirSync(commandsDir)) {
       if (!fileName.endsWith(".md")) continue;
       const commandName = fileName.slice(0, -".md".length);
       entries.push({
         stableId: `command.${commandName}`,
-        srcRelPath: path39.join("library", "global", "commands", fileName),
-        destPath: path39.join(claudeDir, "commands", fileName)
+        srcRelPath: path40.join("library", "global", "commands", fileName),
+        destPath: path40.join(claudeDir, "commands", fileName)
       });
     }
   }
@@ -5883,7 +6154,7 @@ async function applyInstall(options = {}) {
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path39.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path40.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -5897,13 +6168,14 @@ async function applyInstall(options = {}) {
     const newHash = hashContent(stamped);
     const existing = manifestByDest.get(entry.destPath);
     if (check) {
-      if (existing && existing.hash !== newHash) {
+      const destMissing = destFileMissing(entry.destPath);
+      if (destMissing || existing && existing.hash !== newHash) {
         result.drift = true;
         result.skipped.push(entry.destPath);
       }
       continue;
     }
-    const destExists = fs31.pathExistsSync(entry.destPath);
+    const destExists = fs32.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -5943,7 +6215,7 @@ async function applyInstall(options = {}) {
   }
   let mergedSettings;
   if (!check) {
-    const fragmentPath = path39.join(srcDir, "settings-fragments", "hooks.json");
+    const fragmentPath = path40.join(srcDir, "settings-fragments", "hooks.json");
     const fragments = await loadHooksFragment(fragmentPath);
     const settings = await readSettings();
     const { settings: hookSettings, addedIds } = mergeHooks(settings, fragments);
@@ -5957,13 +6229,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 (!fs31.pathExistsSync(entry.destPath)) continue;
+      if (!fs32.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 fs31.remove(entry.destPath);
+        if (!dryRun) await fs32.remove(entry.destPath);
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -6032,7 +6304,7 @@ function summarizeLockDiff(before, after) {
 
 // src/update/lockfile.ts
 import { mkdir, readFile as readFile2, copyFile } from "node:fs/promises";
-import path40 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;
@@ -6056,19 +6328,21 @@ async function checkLock(root) {
   const ok = lock.length > 0 && hasValidVersions && drift.length === 0;
   return { ok, count: lock.length, catalogRef, drift, driftCount: drift.length };
 }
-async function applyLock(root) {
-  const lockPath = hausPath(root, "haus.lock.json");
-  let before = "[]";
+async function readLockRaw(root) {
   try {
-    before = await readFile2(lockPath, "utf8");
+    return await readFile2(hausPath(root, "haus.lock.json"), "utf8");
   } catch {
-    before = "[]";
+    return "[]";
   }
+}
+async function applyLock(root) {
+  const lockPath = hausPath(root, "haus.lock.json");
+  const before = await readLockRaw(root);
   const lock = await readJson(lockPath) ?? [];
   try {
     const backupDir = hausPath(root, "backups");
     await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path40.join(backupDir, `haus.lock.${Date.now()}.json`));
+    await copyFile(lockPath, path41.join(backupDir, `haus.lock.${Date.now()}.json`));
   } catch {
   }
   const enriched = await Promise.all(
@@ -6090,7 +6364,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile2(path40.join(root, ".claude", "settings.json"), "utf8");
+    await readFile2(path41.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -6106,7 +6380,7 @@ async function runUpdate(options) {
     return;
   }
   if (options.check) {
-    const pkgJson2 = await readJson(path41.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, catalogItems, lockItems] = await Promise.all([
       options.fast ? fastLockStatus(root) : checkLock(root),
@@ -6138,10 +6412,12 @@ async function runUpdate(options) {
       )
     );
     const hasHashDrift = !options.fast && status.count > 0 && "ok" in status && !status.ok;
-    if (hasHashDrift || formerIdMigrations.length > 0) process.exitCode = 1;
+    if (hasHashDrift || formerIdMigrations.length > 0 || globalInstallDrift === true) {
+      process.exitCode = 1;
+    }
     return;
   }
-  const pkgJson = await readJson(path41.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) {
@@ -6153,9 +6429,7 @@ async function runUpdate(options) {
   if (await hasLocalOverrides(root)) {
     log("Existing .claude/settings.json \u2014 haus rules will be merged, not replaced.");
   }
-  const { before, after } = await applyLock(root);
-  log(diffLock(before, after));
-  log(summarizeLockDiff(before, after));
+  const lockBefore = await readLockRaw(root);
   log("Syncing remote catalog...");
   const sync = await syncRemoteCatalog();
   if (sync.newItems.length > 0) {
@@ -6177,13 +6451,16 @@ async function runUpdate(options) {
   }
   await refreshGlobalInstall();
   await refreshProjectFiles(root);
+  const { after } = await applyLock(root);
+  log(diffLock(lockBefore, after));
+  log(summarizeLockDiff(lockBefore, after));
   log("Update applied with backup in .haus-workflow/backups/. Run haus doctor.");
 }
 async function runFromHookCheck(root) {
   try {
     const summary = await readLockSummary(root);
     if (summary.count === 0) return;
-    const pkgJson = await readJson(path41.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),
@@ -6333,7 +6610,8 @@ async function runCiGate(options = {}) {
 // src/commands/clone.ts
 init_exec();
 import { existsSync as existsSync2 } from "node:fs";
-import path42 from "node:path";
+import { readdir } from "node:fs/promises";
+import path43 from "node:path";
 var GIT_LOCATION_VARS = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -6362,6 +6640,16 @@ function normalizeGitUrl(url) {
   s = s.replace(/\.git$/i, "");
   return s.toLowerCase();
 }
+async function isEmptyDirectory(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.length === 0;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOTDIR" || code === "ENOENT") return false;
+    throw err;
+  }
+}
 async function checkExistingTarget(target, url) {
   const isRepo = await runGit(["-C", target, "rev-parse", "--is-inside-work-tree"], {
     env: cloneEnv(),
@@ -6383,11 +6671,11 @@ async function runClone(url, opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const target = path42.resolve(opts.dir?.trim() || repoNameFromUrl(url));
-  if (existsSync2(target)) {
+  const target = path43.resolve(opts.dir?.trim() || repoNameFromUrl(url));
+  if (existsSync2(target) && !await isEmptyDirectory(target)) {
     const check = await checkExistingTarget(target, url);
     if (check.kind === "matches") {
-      log(`\u2022 ${path42.basename(target)} already cloned here, matches ${url} \u2014 skipped`);
+      log(`\u2022 ${path43.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].`;
@@ -6427,7 +6715,7 @@ function readHookPayload() {
   if (!raw) return { payload: {}, malformed: false };
   try {
     const parsed = JSON.parse(raw);
-    return { payload: isRecord2(parsed) ? parsed : {}, malformed: false };
+    return { payload: isRecord(parsed) ? parsed : {}, malformed: false };
   } catch {
     return { payload: {}, malformed: true };
   }
@@ -6466,7 +6754,7 @@ function readPayload(options) {
   if (options.stdinPayload != null) {
     try {
       const parsed = JSON.parse(options.stdinPayload);
-      return { payload: isRecord2(parsed) ? parsed : {}, malformed: false };
+      return { payload: isRecord(parsed) ? parsed : {}, malformed: false };
     } catch {
       return { payload: {}, malformed: true };
     }
@@ -6479,15 +6767,14 @@ async function runDecisionsGuard(options = {}) {
     emitPreToolUseDeny("Malformed hook payload");
     return;
   }
-  const toolInput = isRecord2(payload.tool_input) ? payload.tool_input : {};
+  const toolInput = isRecord(payload.tool_input) ? payload.tool_input : {};
   const command = String(toolInput.command ?? "");
   if (!PR_CREATE_PATTERN.test(command)) return;
   const root = process.cwd();
   const baseRef = await resolveBaseRef(root);
   if (!baseRef) return;
   const range = `${baseRef}...HEAD`;
-  const logRange = `${baseRef}..HEAD`;
-  const commitMessages = (await runGit(["log", "--format=%B", logRange], { cwd: root })).stdout;
+  const commitMessages = (await runGit(["log", "--format=%B", toAncestryLogRange(range)], { cwd: root })).stdout;
   const result = await runDecisionsCheck(root, { range, commitMessages });
   if (result.triggered && !result.satisfied) {
     emitPreToolUseDeny(
@@ -6497,7 +6784,7 @@ async function runDecisionsGuard(options = {}) {
 }
 
 // src/commands/decisions.ts
-import path43 from "node:path";
+import path44 from "node:path";
 
 // src/decisions/next-number.ts
 async function nextDecisionNumber(root) {
@@ -6572,7 +6859,7 @@ async function runDecisions(sub, arg, options = {}) {
   const root = process.cwd();
   if (sub === "check") {
     const commitMessages = options.range != null ? (await Promise.resolve().then(() => (init_exec(), exec_exports)).then(
-      (m) => m.runGit(["log", "--format=%B", options.range], { cwd: root })
+      (m) => m.runGit(["log", "--format=%B", toAncestryLogRange(options.range)], { cwd: root })
     )).stdout : "";
     const result = await runDecisionsCheck(root, {
       staged: options.staged,
@@ -6607,7 +6894,7 @@ async function runDecisions(sub, arg, options = {}) {
     return;
   }
   if (sub === "validate") {
-    const target = arg ? path43.resolve(root, arg) : void 0;
+    const target = arg ? path44.resolve(root, arg) : void 0;
     if (!target) {
       error("usage: haus decisions validate <path-to-decision.md>");
       process.exitCode = 1;
@@ -6859,7 +7146,7 @@ async function runGuard(kind, _options) {
     emitPreToolUseDeny("Malformed hook payload");
     return;
   }
-  const toolInput = isRecord2(payload.tool_input) ? payload.tool_input : {};
+  const toolInput = isRecord(payload.tool_input) ? payload.tool_input : {};
   if (kind === "file-access") {
     const candidate = String(toolInput.path ?? toolInput.file_path ?? "");
     const reason2 = guardFileAccess(candidate);
@@ -6876,8 +7163,8 @@ async function runGuard(kind, _options) {
 }
 
 // src/commands/init.ts
-import path45 from "node:path";
-import fs32 from "fs-extra";
+import path46 from "node:path";
+import fs33 from "fs-extra";
 
 // src/recommender/git-signal.ts
 init_exec();
@@ -6900,55 +7187,6 @@ async function readChangedFiles(root) {
   return [.../* @__PURE__ */ new Set([...unstaged, ...staged, ...untracked])].sort();
 }
 
-// src/recommender/policies.ts
-var UNSUPPORTED = FORBIDDEN_TAGS;
-function matchRequiresAny(clauses, ctx) {
-  for (const clause of clauses) {
-    if ("stack" in clause) {
-      if (ctx.stackSet.has(clause.stack.toLowerCase())) {
-        return { matched: true, signal: `stack:${clause.stack}` };
-      }
-    } else if ("dependency" in clause) {
-      if (ctx.depSet.has(clause.dependency.toLowerCase())) {
-        return { matched: true, signal: `dependency:${clause.dependency}` };
-      }
-    } else if ("packageNamePattern" in clause) {
-      const pattern = clause.packageNamePattern.toLowerCase();
-      const prefix = pattern.endsWith("*") ? pattern.slice(0, -1) : pattern;
-      for (const dep2 of ctx.depSet) {
-        if (pattern.endsWith("*") ? dep2.startsWith(prefix) : dep2 === pattern) {
-          return {
-            matched: true,
-            signal: `packageNamePattern:${clause.packageNamePattern}`
-          };
-        }
-      }
-    } else if ("role" in clause) {
-      if (ctx.roleSet.has(clause.role.toLowerCase())) {
-        return { matched: true, signal: `role:${clause.role}` };
-      }
-    }
-  }
-  return { matched: false };
-}
-function describeRequiresAny(clauses) {
-  return clauses.map((c) => {
-    if ("stack" in c) return `stack=${c.stack}`;
-    if ("dependency" in c) return `dependency=${c.dependency}`;
-    if ("packageNamePattern" in c) return `packageNamePattern=${c.packageNamePattern}`;
-    if ("role" in c) return `role=${c.role}`;
-    return "unknown";
-  }).join(" | ");
-}
-function mergeRecommendationWarnings(context, isLinkedWorktree = false) {
-  const markers = context.unsupportedSignals?.join(", ");
-  const statusLines = context.detectionStatus === "unknown" ? [describeUnknownDetection(context.unsupportedSignals ?? [], isLinkedWorktree)] : context.detectionStatus === "partial" && markers ? [
-    `Partially supported \u2014 found unsupported ${markers} alongside recognised stacks; guidance covers the supported parts only.`
-  ] : [];
-  const riskLines = (context.securityRisks?.length ?? 0) > 0 ? [`Scan reported security signals: ${context.securityRisks.join("; ")}`] : [];
-  return [.../* @__PURE__ */ new Set([...statusLines, ...context.warnings, ...riskLines])];
-}
-
 // src/recommender/recommend.ts
 async function recommend(root, context, opts = {}) {
   const items = await loadCatalog(root);
@@ -7265,6 +7503,7 @@ function applyCoInstallSuppression(recommended, skipped) {
 }
 var HARD_SKIP_CODES = /* @__PURE__ */ new Set([
   "former-id",
+  "invalid-source",
   "unsupported-policy",
   "deprecated",
   "curated-not-approved",
@@ -7287,8 +7526,10 @@ function applyManualIncludes(include, items, recommended, skipped) {
     if (recommendedIds.has(id)) continue;
     const skipIdx = skipped.findIndex((s) => s.id === id);
     const skipCode = skipIdx >= 0 ? skipped[skipIdx].skipReasons[0]?.code : void 0;
-    if (skipCode && HARD_SKIP_CODES.has(skipCode)) {
-      warnings.push(`--include: "${id}" cannot be force-installed (blocked by ${skipCode})`);
+    const failingGateNames = skipIdx >= 0 ? (skipped[skipIdx].gates ?? []).filter((g) => !g.passed).map((g) => g.name) : [];
+    const hardBlock = failingGateNames.find((name) => HARD_SKIP_CODES.has(name));
+    if (hardBlock) {
+      warnings.push(`--include: "${id}" cannot be force-installed (blocked by ${hardBlock})`);
       continue;
     }
     if (skipCode === "requires-any-unsatisfied") {
@@ -7344,8 +7585,8 @@ function buildOptInEligible(items, skipped) {
 }
 
 // src/commands/workspace/discover.ts
-import path44 from "node:path";
-import fg4 from "fast-glob";
+import path45 from "node:path";
+import fg5 from "fast-glob";
 import YAML2 from "yaml";
 var DEFAULT_MAX_DEPTH = 3;
 var GIT_MARKER = ["**/.git"];
@@ -7379,16 +7620,16 @@ async function findRepoRoots(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
     suppressErrors: true
   };
   const [gitMatches, manifestMatches] = await Promise.all([
-    fg4(GIT_MARKER, { ...commonOpts, ignore: IGNORE }),
-    fg4(MANIFEST_MARKERS, { ...commonOpts, ignore: [...IGNORE, "**/.git/**"] })
+    fg5(GIT_MARKER, { ...commonOpts, ignore: IGNORE }),
+    fg5(MANIFEST_MARKERS, { ...commonOpts, ignore: [...IGNORE, "**/.git/**"] })
   ]);
   const gitDirs = /* @__PURE__ */ new Set();
   const manifestDirs = /* @__PURE__ */ new Set();
   for (const match of gitMatches) {
-    gitDirs.add(path44.posix.dirname(match));
+    gitDirs.add(path45.posix.dirname(match));
   }
   for (const match of manifestMatches) {
-    manifestDirs.add(path44.posix.dirname(match));
+    manifestDirs.add(path45.posix.dirname(match));
   }
   const repoRoots = [...gitDirs];
   const manifestSorted = [...manifestDirs].sort(
@@ -7405,9 +7646,9 @@ async function findRepoRoots(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
 async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const repoRoots = (await findRepoRoots(workspaceRoot, maxDepth)).filter((dir) => dir !== ".");
   return mapWithConcurrency(repoRoots, async (relDir) => {
-    const absDir = path44.resolve(workspaceRoot, relDir);
-    const pkg = await readJson(path44.join(absDir, "package.json"));
-    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path44.basename(absDir);
+    const absDir = path45.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path45.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path45.basename(absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir);
@@ -7450,7 +7691,7 @@ function renderWorkspaceYaml(config) {
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path44.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path45.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -7628,8 +7869,8 @@ async function runSetupProject(options) {
 // src/commands/init.ts
 async function runInit(options) {
   const root = process.cwd();
-  const hausDir = path45.join(root, ".haus-workflow");
-  const alreadyInit = await fs32.pathExists(hausDir);
+  const hausDir = path46.join(root, ".haus-workflow");
+  const alreadyInit = await fs33.pathExists(hausDir);
   if (alreadyInit) {
     log("Haus AI already initialized in this project.");
     log("Run `haus setup-project` to reconfigure.");
@@ -7764,8 +8005,8 @@ async function runRefresh() {
 }
 
 // src/install/scaffold.ts
-import path46 from "node:path";
-import fs33 from "fs-extra";
+import path47 from "node:path";
+import fs34 from "fs-extra";
 async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   const scaffolded = [];
   const skipped = [];
@@ -7778,27 +8019,27 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
     skipped.push(name);
     if (outcome === "skipped-exists") skippedExisting.push(name);
   };
-  const realRoot = await fs33.realpath(catalogRoot).catch(() => null);
+  const realRoot = await fs34.realpath(catalogRoot).catch(() => null);
   for (const item of items) {
     if (item.type !== "config") continue;
-    const sourcePath = path46.resolve(catalogRoot, item.path);
-    const rel = path46.relative(catalogRoot, sourcePath);
-    const escapes = rel === "" || path46.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
+    const sourcePath = path47.resolve(catalogRoot, item.path);
+    const rel = path47.relative(catalogRoot, sourcePath);
+    const escapes = rel === "" || path47.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
     if (escapes) {
       warn(`Skipping ${item.id}: path '${item.path}' escapes the catalog root`);
       continue;
     }
-    const realSource = await fs33.realpath(sourcePath).catch(() => null);
+    const realSource = await fs34.realpath(sourcePath).catch(() => null);
     if (!realRoot || !realSource) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
     }
-    const realRel = path46.relative(realRoot, realSource);
-    if (realRel !== "" && (path46.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
+    const realRel = path47.relative(realRoot, realSource);
+    if (realRel !== "" && (path47.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
       warn(`Skipping ${item.id}: path '${item.path}' resolves outside the catalog root`);
       continue;
     }
-    const stat = await fs33.lstat(sourcePath).catch(() => null);
+    const stat = await fs34.lstat(sourcePath).catch(() => null);
     if (!stat) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -7808,14 +8049,14 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       continue;
     }
     if (stat.isFile()) {
-      const filename = path46.basename(sourcePath);
-      const dest = path46.join(projectRoot, filename);
+      const filename = path47.basename(sourcePath);
+      const dest = path47.join(projectRoot, filename);
       record(filename, await scaffoldFile(sourcePath, dest, item.id, projectRoot, opts));
     } else if (stat.isDirectory()) {
-      const entries = await fs33.readdir(sourcePath);
+      const entries = await fs34.readdir(sourcePath);
       for (const entry of entries) {
-        const src = path46.join(sourcePath, entry);
-        const dest = path46.join(projectRoot, entry);
+        const src = path47.join(sourcePath, entry);
+        const dest = path47.join(projectRoot, entry);
         record(entry, await scaffoldFile(src, dest, item.id, projectRoot, opts));
       }
     }
@@ -7823,42 +8064,42 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   return { scaffolded, skipped, skippedExisting };
 }
 async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
-  const destDisplay = path46.relative(projectRoot, dest) || path46.basename(dest);
-  const srcStat = await fs33.lstat(src).catch(() => null);
+  const destDisplay = path47.relative(projectRoot, dest) || path47.basename(dest);
+  const srcStat = await fs34.lstat(src).catch(() => null);
   if (!srcStat) {
-    warn(`Skipping ${path46.basename(src)}: source not found`);
+    warn(`Skipping ${path47.basename(src)}: source not found`);
     return "skipped-refused";
   }
   if (srcStat.isSymbolicLink()) {
-    warn(`Skipping ${path46.basename(src)}: source is a symlink`);
+    warn(`Skipping ${path47.basename(src)}: source is a symlink`);
     return "skipped-refused";
   }
-  const exists = await fs33.pathExists(dest);
+  const exists = await fs34.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"} ${path46.basename(dest)} (${itemId})`);
+    log(`[dry-run] would ${exists ? "overwrite" : "create"} ${path47.basename(dest)} (${itemId})`);
     return "scaffolded";
   }
   if (exists && opts.force) {
-    await fs33.remove(dest);
+    await fs34.remove(dest);
   }
-  await fs33.ensureDir(path46.dirname(dest));
-  await fs33.copy(src, dest, {
+  await fs34.ensureDir(path47.dirname(dest));
+  await fs34.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 !fs33.lstatSync(s).isSymbolicLink();
+        return !fs34.lstatSync(s).isSymbolicLink();
       } catch {
         return false;
       }
     }
   });
-  log(`${exists ? "Overwrote" : "Created"} ${path46.basename(dest)} (${itemId})`);
+  log(`${exists ? "Overwrote" : "Created"} ${path47.basename(dest)} (${itemId})`);
   return "scaffolded";
 }
 
@@ -7923,8 +8164,8 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path47 from "node:path";
-import fs34 from "fs-extra";
+import path48 from "node:path";
+import fs35 from "fs-extra";
 
 // src/claude/managed-paths.ts
 var PROJECT_MANAGED_CLAUDE_REL = ["rules/haus.md"];
@@ -7939,7 +8180,7 @@ function coreManagedAbsolutePaths(root) {
 async function collectCoreManagedPaths(root) {
   const existing = [];
   for (const abs of coreManagedAbsolutePaths(root)) {
-    if (await fs34.pathExists(abs)) existing.push(abs);
+    if (await fs35.pathExists(abs)) existing.push(abs);
   }
   return existing;
 }
@@ -7951,18 +8192,18 @@ async function collectLockTrackedPaths(root) {
     const relPaths = row.paths ?? [];
     const existingRel = [];
     for (const rel of relPaths) {
-      if (await fs34.pathExists(path47.resolve(root, rel))) existingRel.push(rel);
+      if (await fs35.pathExists(path48.resolve(root, rel))) existingRel.push(rel);
     }
     if (existingRel.length === 0) continue;
     if (row.hash === void 0) {
-      removable.push(...existingRel.map((rel) => path47.resolve(root, rel)));
+      removable.push(...existingRel.map((rel) => path48.resolve(root, rel)));
       continue;
     }
     const currentHash = await hashInstalledPaths(root, existingRel);
     if (currentHash === row.hash) {
-      removable.push(...existingRel.map((rel) => path47.resolve(root, rel)));
+      removable.push(...existingRel.map((rel) => path48.resolve(root, rel)));
     } else {
-      preserved.push(...existingRel.map((rel) => path47.resolve(root, rel)));
+      preserved.push(...existingRel.map((rel) => path48.resolve(root, rel)));
       log(`Preserving locally-modified ${row.id ?? "(unknown item)"}: ${existingRel.join(", ")}`);
     }
   }
@@ -7970,51 +8211,51 @@ async function collectLockTrackedPaths(root) {
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs34.pathExists(settingsPath)) return false;
+  if (!await fs35.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path47.join(root, "CLAUDE.md");
-  if (!await fs34.pathExists(filePath)) return false;
-  const text = await fs34.readFile(filePath, "utf8");
+  const filePath = path48.join(root, "CLAUDE.md");
+  if (!await fs35.pathExists(filePath)) return false;
+  const text = await fs35.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs34.pathExists(settingsPath)) return false;
+  if (!await fs35.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 ${path47.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path48.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs34.remove(settingsPath);
-  log(`Removed ${path47.relative(root, settingsPath)} (no user-owned settings remained).`);
+  await fs35.remove(settingsPath);
+  log(`Removed ${path48.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path47.join(root, "CLAUDE.md");
-  if (!await fs34.pathExists(filePath)) return false;
-  const prev = await fs34.readFile(filePath, "utf8");
+  const filePath = path48.join(root, "CLAUDE.md");
+  if (!await fs35.pathExists(filePath)) return false;
+  const prev = await fs35.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs34.remove(filePath);
+    await fs35.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs34.writeFile(filePath, next, "utf8");
+    await fs35.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs34.pathExists(dir)) return;
+  if (!await fs35.pathExists(dir)) return;
   try {
-    const entries = await fs34.readdir(dir);
-    if (entries.length === 0) await fs34.remove(dir);
+    const entries = await fs35.readdir(dir);
+    if (entries.length === 0) await fs35.remove(dir);
   } catch {
   }
 }
@@ -8023,13 +8264,13 @@ 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 fs34.pathExists(abs)) continue;
-    const rel = path47.relative(root, abs);
-    const backupPath = path47.join(backupRoot, rel);
-    await fs34.ensureDir(path47.dirname(backupPath));
-    await fs34.copy(abs, backupPath);
+    if (!await fs35.pathExists(abs)) continue;
+    const rel = path48.relative(root, abs);
+    const backupPath = path48.join(backupRoot, rel);
+    await fs35.ensureDir(path48.dirname(backupPath));
+    await fs35.copy(abs, backupPath);
   }
-  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path47.relative(root, backupRoot)}.`);
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path48.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
   const root = options.root ?? process.cwd();
@@ -8042,7 +8283,7 @@ async function runUndo(options) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path47.relative(root, p));
+  const relTargets = managed.map((p) => path48.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)");
@@ -8064,9 +8305,9 @@ User-owned .claude/ files will be preserved.`
   }
   await backupManagedFilesBeforeUndo(root, managed);
   for (const abs of managed) {
-    if (!await fs34.pathExists(abs)) continue;
-    await fs34.remove(abs);
-    log(`Removed ${path47.relative(root, abs)}`);
+    if (!await fs35.pathExists(abs)) continue;
+    await fs35.remove(abs);
+    log(`Removed ${path48.relative(root, abs)}`);
   }
   if (stripSettings) await stripProjectSettings(root);
   if (stripClaudeMd) await stripRootClaudeMd(root);
@@ -8077,8 +8318,8 @@ User-owned .claude/ files will be preserved.`
 
 // src/install/uninstall.ts
 import crypto3 from "node:crypto";
-import path48 from "node:path";
-import fs35 from "fs-extra";
+import path49 from "node:path";
+import fs36 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
   const manifest = await readManifest();
@@ -8088,7 +8329,7 @@ async function runUninstall(options = {}) {
     return result;
   }
   for (const entry of manifest.files) {
-    const exists = fs35.pathExistsSync(entry.destPath);
+    const exists = fs36.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -8106,23 +8347,23 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs35.remove(entry.destPath);
-    await pruneEmptyDir(path48.dirname(entry.destPath));
+    await fs36.remove(entry.destPath);
+    await pruneEmptyDir(path49.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 = path48.join(globalClaudeDir(), "haus");
+  const hausDir = path49.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs35.pathExistsSync(manifestPath2)) {
-    await fs35.remove(manifestPath2);
+  if (fs36.pathExistsSync(manifestPath2)) {
+    await fs36.remove(manifestPath2);
   }
-  if (fs35.pathExistsSync(hausDir)) {
+  if (fs36.pathExistsSync(hausDir)) {
     try {
-      const remaining = await fs35.readdir(hausDir);
-      if (remaining.length === 0) await fs35.remove(hausDir);
+      const remaining = await fs36.readdir(hausDir);
+      if (remaining.length === 0) await fs36.remove(hausDir);
     } catch {
     }
   }
@@ -8145,6 +8386,19 @@ function printUninstallResult(result) {
 // src/commands/uninstall.ts
 async function runUninstallCommand(options) {
   try {
+    if (!options.yes) {
+      const manifest = await readManifest();
+      if (manifest) {
+        const fileCount = manifest.files.length;
+        const ok = await confirm(
+          fileCount > 0 ? `Remove ${fileCount} haus-managed file(s) from ~/.claude/ and strip haus hook entries from settings.json?` : "Strip haus hook entries from ~/.claude/settings.json and remove the install manifest?"
+        );
+        if (!ok) {
+          log("Cancelled.");
+          return;
+        }
+      }
+    }
     const result = await runUninstall({ force: options.force });
     printUninstallResult(result);
     log("haus uninstall complete");
@@ -8155,11 +8409,11 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/validate-catalog.ts
-import path50 from "node:path";
+import path51 from "node:path";
 
 // src/catalog/validate-core.ts
-import fs36 from "node:fs";
-import path49 from "node:path";
+import fs37 from "node:fs";
+import path50 from "node:path";
 var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
 var ITEM_ID_PATTERN = /^haus\./;
 function auditForbiddenStacks(items) {
@@ -8301,14 +8555,14 @@ function checkRequiredFrontmatter(text, label) {
 }
 function readForAudit(absPath, label, failures) {
   try {
-    return fs36.readFileSync(absPath, "utf8");
+    return fs37.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 = path49.relative(manifestDir, absPath);
+  const rel = path50.relative(manifestDir, absPath);
   const failures = [];
   const text = readForAudit(absPath, `${itemId}: ${rel}`, failures);
   if (text === null) return failures;
@@ -8330,47 +8584,47 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path || !isSafeCatalogPath(item.path)) continue;
-    const absPath = path49.join(manifestDir, item.path);
+    const absPath = path50.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path49.join(absPath, "SKILL.md");
-      if (!fs36.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path49.relative(manifestDir, skillMd)}`);
+      const skillMd = path50.join(absPath, "SKILL.md");
+      if (!fs37.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path50.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}: ${path49.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path50.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs36.existsSync(absPath)) {
+      if (!fs37.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const rel = path49.relative(manifestDir, absPath);
+      const rel = path50.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 (!fs36.existsSync(absPath)) {
+      if (!fs37.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 (!fs36.existsSync(absPath)) {
+      if (!fs37.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
-      const rel = path49.relative(manifestDir, absPath);
+      const rel = path50.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 (!fs36.existsSync(absPath)) {
+      if (!fs37.existsSync(absPath)) {
         failures.push(`${item.id}: missing config path ${item.path}`);
       }
     }
@@ -8387,7 +8641,7 @@ var CONTENT_ROOTS = ["skills", "agents", "templates", "commands", "configs"];
 function walkAllFiles(dir, fn, failures) {
   let entries;
   try {
-    entries = fs36.readdirSync(dir, { withFileTypes: true });
+    entries = fs37.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -8396,7 +8650,7 @@ function walkAllFiles(dir, fn, failures) {
   }
   for (const entry of entries) {
     if (entry.name === ".DS_Store") continue;
-    const full = path49.join(dir, entry.name);
+    const full = path50.join(dir, entry.name);
     if (entry.isDirectory()) walkAllFiles(full, fn, failures);
     else fn(full);
   }
@@ -8414,12 +8668,12 @@ function auditDiskOrphans(manifestDir, items) {
   const failures = [];
   const claimedPaths = items.filter((item) => item.path && isSafeCatalogPath(item.path)).map((item) => item.path.replace(/\\/g, "/"));
   for (const dir of CONTENT_ROOTS) {
-    const abs = path49.join(manifestDir, dir);
-    if (!fs36.existsSync(abs)) continue;
+    const abs = path50.join(manifestDir, dir);
+    if (!fs37.existsSync(abs)) continue;
     walkAllFiles(
       abs,
       (file) => {
-        const relPath = path49.relative(manifestDir, file).replace(/\\/g, "/");
+        const relPath = path50.relative(manifestDir, file).replace(/\\/g, "/");
         if (!isPathClaimed(relPath, claimedPaths)) {
           failures.push(`orphaned on disk, claimed by no manifest item: ${relPath}`);
         }
@@ -8432,7 +8686,7 @@ function auditDiskOrphans(manifestDir, items) {
 function walkMd(dir, fn, failures) {
   let entries;
   try {
-    entries = fs36.readdirSync(dir, { withFileTypes: true });
+    entries = fs37.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -8440,7 +8694,7 @@ function walkMd(dir, fn, failures) {
     return;
   }
   for (const entry of entries) {
-    const full = path49.join(dir, entry.name);
+    const full = path50.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn, failures);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -8449,13 +8703,13 @@ function auditMarkdownContent(manifestDir, items) {
   const failures = [];
   const pathSourceMap = buildItemPathSourceMap(items);
   for (const dir of ["skills", "agents", "templates", "commands"]) {
-    const abs = path49.join(manifestDir, dir);
-    if (!fs36.existsSync(abs)) continue;
+    const abs = path50.join(manifestDir, dir);
+    if (!fs37.existsSync(abs)) continue;
     const dirType = DIR_ITEM_TYPE[dir] ?? "";
     walkMd(
       abs,
       (file) => {
-        const rel = path49.relative(manifestDir, file);
+        const rel = path50.relative(manifestDir, file);
         const text = readForAudit(file, rel, failures);
         if (text === null) return;
         const norm = rel.replace(/\\/g, "/");
@@ -8500,8 +8754,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path50.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path50.dirname(abs);
+  const abs = path51.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path51.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -8518,8 +8772,8 @@ async function runValidateCatalog(manifestPath2) {
 }
 
 // src/workspace/worktree/add.ts
-import path57 from "node:path";
-import fs40 from "fs-extra";
+import path58 from "node:path";
+import fs41 from "fs-extra";
 
 // src/workspace/worktree/git-worktree.ts
 init_exec();
@@ -8638,13 +8892,13 @@ async function hasUnpushedWork(cwd) {
 }
 
 // src/workspace/worktree/hydrate.ts
-import path53 from "node:path";
-import fs38 from "fs-extra";
+import path54 from "node:path";
+import fs39 from "fs-extra";
 
 // src/workspace/worktree/cow-copy.ts
 init_exec();
-import path51 from "node:path";
-import fs37 from "fs-extra";
+import path52 from "node:path";
+import fs38 from "fs-extra";
 async function getMacFilesystemType(dir) {
   const df = await runCommand("df", ["-P", dir]);
   if (df.exitCode !== 0) return void 0;
@@ -8675,14 +8929,14 @@ async function detectCowStrategy(dir) {
   return "unknown-platform";
 }
 async function cowCopyDir(src, dest) {
-  const srcExists = await fs37.pathExists(src);
+  const srcExists = await fs38.pathExists(src);
   if (!srcExists)
     return { strategy: "unsupported", attempted: false, ok: false, error: "source missing" };
-  const strategy = await detectCowStrategy(path51.dirname(dest));
+  const strategy = await detectCowStrategy(path52.dirname(dest));
   if (strategy === "unsupported" || strategy === "unknown-platform") {
     return { strategy, attempted: false, ok: false };
   }
-  await fs37.ensureDir(path51.dirname(dest));
+  await fs38.ensureDir(path52.dirname(dest));
   const args = strategy === "darwin-clonefile" ? ["-c", "-R", src, dest] : ["-a", "--reflink=always", src, dest];
   const result = await runCommand("cp", args);
   return {
@@ -8696,8 +8950,8 @@ async function cowCopyDir(src, dest) {
 // src/workspace/worktree/install.ts
 init_exec();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import path52 from "node:path";
-import fg5 from "fast-glob";
+import path53 from "node:path";
+import fg6 from "fast-glob";
 function detectInstallPlan(signals) {
   if (signals.hasYarnLock) {
     return signals.hasPackageManagerField ? { manager: "yarn", command: "corepack", args: ["yarn", "install"] } : { manager: "yarn", command: "yarn", args: ["install"] };
@@ -8717,11 +8971,11 @@ function detectInstallPlan(signals) {
   return { manager: "none" };
 }
 async function computeLockfileSignals(dir) {
-  const hasYarnLock = existsSync3(path52.join(dir, "yarn.lock"));
-  const hasPnpmLock = existsSync3(path52.join(dir, "pnpm-lock.yaml"));
-  const hasPackageLock = existsSync3(path52.join(dir, "package-lock.json"));
-  const hasComposerLock = existsSync3(path52.join(dir, "composer.lock"));
-  const dotnetFiles = await fg5(["**/*.csproj", "**/*.sln"], {
+  const hasYarnLock = existsSync3(path53.join(dir, "yarn.lock"));
+  const hasPnpmLock = existsSync3(path53.join(dir, "pnpm-lock.yaml"));
+  const hasPackageLock = existsSync3(path53.join(dir, "package-lock.json"));
+  const hasComposerLock = existsSync3(path53.join(dir, "composer.lock"));
+  const dotnetFiles = await fg6(["**/*.csproj", "**/*.sln"], {
     cwd: dir,
     onlyFiles: true,
     suppressErrors: true,
@@ -8734,7 +8988,7 @@ async function computeLockfileSignals(dir) {
   });
   const hasDotnetProject = dotnetFiles.length > 0;
   let hasPackageManagerField = false;
-  const pkgPath = path52.join(dir, "package.json");
+  const pkgPath = path53.join(dir, "package.json");
   if (existsSync3(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
@@ -8775,13 +9029,13 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
   const start = Date.now();
   const targets = [];
   for (const target of HYDRATION_TARGETS) {
-    const src = path53.join(mainMemberPath, target);
-    const dest = path53.join(worktreeMemberPath, target);
-    if (!await fs38.pathExists(src)) continue;
-    const destExists = await fs38.pathExists(dest);
+    const src = path54.join(mainMemberPath, target);
+    const dest = path54.join(worktreeMemberPath, target);
+    if (!await fs39.pathExists(src)) continue;
+    const destExists = await fs39.pathExists(dest);
     if (!opts.force && destExists) continue;
     if (opts.force && destExists) {
-      await fs38.remove(dest);
+      await fs39.remove(dest);
     }
     const copy = await cowCopyDir(src, dest);
     targets.push({ target, copy });
@@ -8794,11 +9048,11 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
 
 // src/workspace/worktree/local-files.ts
 init_exec();
-import path54 from "node:path";
-import fs39 from "fs-extra";
+import path55 from "node:path";
+import fs40 from "fs-extra";
 var MACHINE_LOCAL_FILES = [
   "docker-compose.local.yml",
-  path54.join(".claude", "settings.local.json")
+  path55.join(".claude", "settings.local.json")
 ];
 async function isTracked(repoRoot, relFile) {
   const gitPath = relFile.replace(/\\/g, "/");
@@ -8808,12 +9062,12 @@ async function isTracked(repoRoot, relFile) {
 async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
   const copied = [];
   for (const rel of MACHINE_LOCAL_FILES) {
-    const src = path54.join(mainMemberPath, rel);
-    if (!await fs39.pathExists(src)) continue;
+    const src = path55.join(mainMemberPath, rel);
+    if (!await fs40.pathExists(src)) continue;
     if (await isTracked(mainMemberPath, rel)) continue;
-    const dest = path54.join(worktreeMemberPath, rel);
-    await fs39.ensureDir(path54.dirname(dest));
-    await fs39.copy(src, dest, { overwrite: true });
+    const dest = path55.join(worktreeMemberPath, rel);
+    await fs40.ensureDir(path55.dirname(dest));
+    await fs40.copy(src, dest, { overwrite: true });
     copied.push(rel);
   }
   return copied;
@@ -8821,15 +9075,15 @@ async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
 
 // src/workspace/worktree/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 async function resolveWorkspaceForWorktree(start) {
   const rootInfo = await resolveRoots(start);
   if (!rootInfo.isGitRepo) {
     return { ok: false, reason: "Not inside a git repository." };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const hasYaml = existsSync4(path55.join(workspaceRoot, WORKSPACE_FILE));
-  const hasManifest = existsSync4(path55.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const hasYaml = existsSync4(path56.join(workspaceRoot, WORKSPACE_FILE));
+  const hasManifest = existsSync4(path56.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!hasYaml && !hasManifest) {
     return {
       ok: false,
@@ -8854,19 +9108,31 @@ function selectMembers(members, only) {
 }
 
 // src/workspace/worktree/state.ts
-import path56 from "node:path";
+import path57 from "node:path";
 var WORKTREE_STATE_FILE = ".haus-worktree.json";
 function worktreesDir(mainRoot) {
-  return path56.join(mainRoot, ".claude", "worktrees");
+  return path57.join(mainRoot, ".claude", "worktrees");
+}
+function isValidWorktreeSlug(slug) {
+  if (slug === "" || slug === "." || slug === "..") return false;
+  if (slug.includes("/") || slug.includes("\\")) return false;
+  return /^[A-Za-z0-9._-]+$/.test(slug);
 }
 function worktreePath(mainRoot, slug) {
-  return path56.join(worktreesDir(mainRoot), slug);
+  if (!isValidWorktreeSlug(slug)) {
+    throw new Error(
+      `Invalid worktree slug ${JSON.stringify(slug)} \u2014 slugs may only contain letters, digits, ".", "_", "-" (no path separators, and not "." or "..").`
+    );
+  }
+  return path57.join(worktreesDir(mainRoot), slug);
 }
 async function readWorktreeState(worktreeRoot) {
-  return readJson(path56.join(worktreeRoot, WORKTREE_STATE_FILE));
+  const state = await readJson(path57.join(worktreeRoot, WORKTREE_STATE_FILE));
+  if (state == null || typeof state !== "object" || !Array.isArray(state.members)) return void 0;
+  return state;
 }
 async function writeWorktreeState(worktreeRoot, state) {
-  await writeJson(path56.join(worktreeRoot, WORKTREE_STATE_FILE), state);
+  await writeJson(path57.join(worktreeRoot, WORKTREE_STATE_FILE), state);
 }
 
 // src/workspace/worktree/add.ts
@@ -8881,7 +9147,7 @@ async function runAdd(opts) {
   }
   const branch = opts.branch ?? opts.slug;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (await fs40.pathExists(wsWorktreePath)) {
+  if (await fs41.pathExists(wsWorktreePath)) {
     return {
       ok: false,
       error: `Workspace worktree already exists at ${wsWorktreePath} \u2014 run \`haus workspace worktree hydrate --materialize\` from inside it to check out any missing members (e.g. a worktree created by plain \`git worktree add\`), or \`remove\` first to start over.`
@@ -8900,7 +9166,7 @@ async function runAdd(opts) {
   const memberResults = [];
   for (const member of selected) {
     const start = Date.now();
-    const memberWorktreePath = path57.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path58.join(wsWorktreePath, member.folder);
     const outcome = await addWorktree(member.absPath, memberWorktreePath, branch, {
       preferDefaultBranchFrom: true
     });
@@ -8930,7 +9196,7 @@ async function runAdd(opts) {
   await mapWithConcurrency(okResults, async (result) => {
     const member = selected.find((m) => m.id === result.member);
     if (!member) return;
-    const memberWorktreePath = path57.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path58.join(wsWorktreePath, member.folder);
     const hydrationStart = Date.now();
     if (opts.hydrate !== false) {
       result.hydration = await hydrateMember(member.absPath, memberWorktreePath);
@@ -8997,10 +9263,10 @@ async function runDryRun(args) {
 
 // src/workspace/worktree/doctor.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path58 from "node:path";
+import path59 from "node:path";
 var HYDRATION_MARKERS = ["node_modules", "vendor", "obj", "bin"];
 function looksHydrated(memberPath) {
-  return HYDRATION_MARKERS.some((marker) => existsSync5(path58.join(memberPath, marker)));
+  return HYDRATION_MARKERS.some((marker) => existsSync5(path59.join(memberPath, marker)));
 }
 async function runDoctor2() {
   const rootInfo = await resolveRoots();
@@ -9014,7 +9280,7 @@ async function runDoctor2() {
     };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const isWorkspace = existsSync5(path58.join(workspaceRoot, WORKSPACE_FILE)) || existsSync5(path58.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const isWorkspace = existsSync5(path59.join(workspaceRoot, WORKSPACE_FILE)) || existsSync5(path59.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!isWorkspace) {
     return {
       isWorkspace: false,
@@ -9027,7 +9293,7 @@ async function runDoctor2() {
     };
   }
   const wsWorktreesDir = worktreesDir(workspaceRoot);
-  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path58.sep}`);
+  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path59.sep}`);
   const inWorkspaceWorktree = rootInfo.isLinkedWorktree && underWorktreesDir;
   const members = await readMembers(rootInfo);
   const problems = [];
@@ -9035,10 +9301,10 @@ async function runDoctor2() {
   let slug;
   if (inWorkspaceWorktree) {
     const wtPath = rootInfo.repoRoot;
-    slug = rootInfo.worktreeName ?? path58.basename(wtPath);
+    slug = rootInfo.worktreeName ?? path59.basename(wtPath);
     const state = await readWorktreeState(wtPath);
     for (const member of members) {
-      const memberPath = path58.join(wtPath, member.folder);
+      const memberPath = path59.join(wtPath, member.folder);
       const materialized = existsSync5(memberPath);
       const expectedBranch = state?.members.find((m) => m.folder === member.folder)?.branch ?? state?.branch;
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
@@ -9069,16 +9335,16 @@ async function runDoctor2() {
   for (const member of members) {
     const entries = await listWorktrees(member.absPath);
     for (const entry of entries) {
-      const entryPath = path58.normalize(entry.path);
-      const marker = `${path58.sep}.claude${path58.sep}worktrees${path58.sep}`;
+      const entryPath = path59.normalize(entry.path);
+      const marker = `${path59.sep}.claude${path59.sep}worktrees${path59.sep}`;
       const idx = entryPath.indexOf(marker);
       if (idx === -1) continue;
       const rest = entryPath.slice(idx + marker.length);
-      const slugName = rest.split(path58.sep)[0];
+      const slugName = rest.split(path59.sep)[0];
       if (!slugName) continue;
-      if (!existsSync5(path58.join(wsWorktreesDir, slugName))) {
+      if (!existsSync5(path59.join(wsWorktreesDir, slugName))) {
         orphans.push(
-          `${member.id}: worktree registered at ${entry.path} but ${path58.join(wsWorktreesDir, slugName)} no longer exists \u2014 run \`git -C "${member.absPath}" worktree prune\`.`
+          `${member.id}: worktree registered at ${entry.path} but ${path59.join(wsWorktreesDir, slugName)} no longer exists \u2014 run \`git -C "${member.absPath}" worktree prune\`.`
         );
       }
     }
@@ -9089,7 +9355,7 @@ async function runDoctor2() {
 
 // src/workspace/worktree/hydrate-command.ts
 import { existsSync as existsSync6 } from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 async function runHydrateWorktree(opts) {
   const rootInfo = await resolveRoots();
   if (!rootInfo.isGitRepo || !rootInfo.isLinkedWorktree) {
@@ -9100,7 +9366,7 @@ async function runHydrateWorktree(opts) {
   }
   const workspaceRoot = rootInfo.mainRoot;
   const wtPath = rootInfo.repoRoot;
-  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path59.sep}`)) {
+  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path60.sep}`)) {
     return {
       ok: false,
       error: "Current worktree is not one of this workspace's .claude/worktrees/<slug> checkouts."
@@ -9112,13 +9378,13 @@ async function runHydrateWorktree(opts) {
     return { ok: false, error: `Unknown --only repo(s): ${unknown.join(", ")}` };
   }
   const state = await readWorktreeState(wtPath);
-  const slug = state?.slug ?? path59.basename(wtPath);
+  const slug = state?.slug ?? path60.basename(wtPath);
   const detectedBranch = await currentBranch(wtPath);
   const targetBranch = state?.branch ?? (detectedBranch !== "HEAD" ? detectedBranch : void 0) ?? slug;
   if (opts.dryRun) {
     const results2 = await Promise.all(
       selected.map(async (member) => {
-        const memberPath = path59.join(wtPath, member.folder);
+        const memberPath = path60.join(wtPath, member.folder);
         if (existsSync6(memberPath)) {
           return { member: member.id, folder: member.folder, status: "planned" };
         }
@@ -9139,7 +9405,7 @@ async function runHydrateWorktree(opts) {
   const results = await mapWithConcurrency(
     selected,
     async (member) => {
-      const memberPath = path59.join(wtPath, member.folder);
+      const memberPath = path60.join(wtPath, member.folder);
       let branchAction;
       if (!existsSync6(memberPath)) {
         if (!opts.materialize) {
@@ -9202,26 +9468,26 @@ async function runHydrateWorktree(opts) {
 }
 
 // src/workspace/worktree/list.ts
-import path60 from "node:path";
-import fs41 from "fs-extra";
+import path61 from "node:path";
+import fs42 from "fs-extra";
 async function runList2() {
   const resolved = await resolveWorkspaceForWorktree();
   if (!resolved.ok) return { ok: false, error: resolved.reason };
   const { rootInfo, workspaceRoot } = resolved;
   const dir = worktreesDir(workspaceRoot);
-  if (!await fs41.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
-  const entries = await fs41.readdir(dir, { withFileTypes: true });
+  if (!await fs42.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
+  const entries = await fs42.readdir(dir, { withFileTypes: true });
   const slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   const configuredMembers = await readMembers(rootInfo);
   const worktrees = [];
   for (const slug of slugs) {
-    const wtPath = path60.join(dir, slug);
+    const wtPath = path61.join(dir, slug);
     const state = await readWorktreeState(wtPath);
     const members = [];
     const source = state?.members ?? configuredMembers.map((m) => ({ id: m.id, folder: m.folder }));
     for (const m of source) {
-      const memberPath = path60.join(wtPath, m.folder);
-      const materialized = await fs41.pathExists(memberPath);
+      const memberPath = path61.join(wtPath, m.folder);
+      const materialized = await fs42.pathExists(memberPath);
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
       members.push({
         id: m.id,
@@ -9242,14 +9508,14 @@ async function runList2() {
 }
 
 // src/workspace/worktree/remove.ts
-import path61 from "node:path";
-import fs42 from "fs-extra";
+import path62 from "node:path";
+import fs43 from "fs-extra";
 async function runRemove(opts) {
   const resolved = await resolveWorkspaceForWorktree();
   if (!resolved.ok) return { ok: false, error: resolved.reason };
   const { rootInfo, workspaceRoot } = resolved;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (!await fs42.pathExists(wsWorktreePath)) {
+  if (!await fs43.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const state = await readWorktreeState(wsWorktreePath);
@@ -9269,12 +9535,12 @@ async function runRemove(opts) {
     targets.push({
       repo: configMember?.id ?? stateMember.id,
       ownerRepo,
-      path: path61.join(wsWorktreePath, stateMember.folder)
+      path: path62.join(wsWorktreePath, stateMember.folder)
     });
   }
   const existingTargets = [];
   for (const target of targets) {
-    if (await fs42.pathExists(target.path)) existingTargets.push(target);
+    if (await fs43.pathExists(target.path)) existingTargets.push(target);
   }
   if (!opts.force) {
     const blockers = [];
@@ -9319,14 +9585,19 @@ async function runRemove(opts) {
     await pruneWorktrees(target.ownerRepo);
   }
   const wsTarget = existingTargets.find((t) => t.repo === "(workspace)");
+  let wsRemoveOk = false;
   if (wsTarget) {
     const wsResult = await removeWorktree(workspaceRoot, wsWorktreePath);
-    if (wsResult.ok) removed.push("(workspace)");
-    else failed.push({ repo: "(workspace)", error: wsResult.stderr ?? "unknown error" });
+    if (wsResult.ok) {
+      removed.push("(workspace)");
+      wsRemoveOk = true;
+    } else {
+      failed.push({ repo: "(workspace)", error: wsResult.stderr ?? "unknown error" });
+    }
     await pruneWorktrees(workspaceRoot);
   }
-  if (await fs42.pathExists(wsWorktreePath)) {
-    await fs42.remove(wsWorktreePath);
+  if (wsRemoveOk && await fs43.pathExists(wsWorktreePath)) {
+    await fs43.remove(wsWorktreePath);
   }
   return { ok: failed.length === 0, dryRun: false, slug: opts.slug, removed, failed };
 }
@@ -9541,7 +9812,7 @@ async function runWorktree(action, opts = {}) {
 
 // src/commands/workspace.ts
 import { existsSync as existsSync10, statSync as statSync3 } from "node:fs";
-import path70 from "node:path";
+import path71 from "node:path";
 
 // src/commands/workspace/aggregate.ts
 async function writeWorkspaceArtifacts(workspaceRoot, repos, relationships = []) {
@@ -9596,18 +9867,18 @@ ${summaries.map(
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync7 } from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 
 // src/commands/workspace/manifest.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 var MANIFEST_FILE = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync4(path62.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path63.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -9688,10 +9959,18 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
     });
     return emit({ workspaceRoot, manifest, drift, detail, json: opts.json });
   }
+  if (!Array.isArray(manifest.repos)) {
+    flag({
+      repo: "(workspace)",
+      kind: "no-manifest",
+      detail: 'workspace.manifest.json\'s "repos" field is not an array \u2014 run `haus workspace setup --write` to regenerate it.'
+    });
+    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 = path63.resolve(workspaceRoot, repo.path);
+    const repoRoot = path64.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -9764,7 +10043,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         });
         continue;
       }
-      if (!existsSync7(path63.join(workspaceRoot, entry.path))) {
+      if (!existsSync7(path64.join(workspaceRoot, entry.path))) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-copy",
@@ -9807,16 +10086,16 @@ function emit(args) {
 }
 
 // src/workspace/link-context/link.ts
+import path67 from "node:path";
+import fs46 from "fs-extra";
+
+// src/workspace/link-context/plan.ts
 import path66 from "node:path";
 import fs45 from "fs-extra";
 
-// src/workspace/link-context/plan.ts
+// src/workspace/link-context/scan-source.ts
 import path65 from "node:path";
 import fs44 from "fs-extra";
-
-// src/workspace/link-context/scan-source.ts
-import path64 from "node:path";
-import fs43 from "fs-extra";
 var ASSET_SUBDIR = {
   skill: "skills",
   agent: "agents",
@@ -9824,36 +10103,36 @@ var ASSET_SUBDIR = {
 };
 async function hasLinkableContext(member) {
   for (const subdir of Object.values(ASSET_SUBDIR)) {
-    if (await fs43.pathExists(path64.join(member.absPath, ".claude", subdir))) return true;
+    if (await fs44.pathExists(path65.join(member.absPath, ".claude", subdir))) return true;
   }
   return false;
 }
 async function collectSkills(member) {
-  const dir = path64.join(member.absPath, ".claude", "skills");
-  if (!await fs43.pathExists(dir)) return [];
-  const names = await fs43.readdir(dir);
+  const dir = path65.join(member.absPath, ".claude", "skills");
+  if (!await fs44.pathExists(dir)) return [];
+  const names = await fs44.readdir(dir);
   const out = [];
   for (const name of [...names].sort()) {
-    const abs = path64.join(dir, name);
-    const stat = await fs43.lstat(abs);
+    const abs = path65.join(dir, name);
+    const stat = await fs44.lstat(abs);
     if (!stat.isDirectory()) continue;
-    if (!await fs43.pathExists(path64.join(abs, "SKILL.md"))) continue;
-    out.push({ type: "skill", name, sourceRelPath: path64.posix.join(".claude", "skills", name) });
+    if (!await fs44.pathExists(path65.join(abs, "SKILL.md"))) continue;
+    out.push({ type: "skill", name, sourceRelPath: path65.posix.join(".claude", "skills", name) });
   }
   return out;
 }
 async function collectFlatMarkdown(member, type) {
   const subdir = ASSET_SUBDIR[type];
-  const dir = path64.join(member.absPath, ".claude", subdir);
-  if (!await fs43.pathExists(dir)) return [];
-  const names = await fs43.readdir(dir);
+  const dir = path65.join(member.absPath, ".claude", subdir);
+  if (!await fs44.pathExists(dir)) return [];
+  const names = await fs44.readdir(dir);
   const out = [];
   for (const fileName of [...names].sort()) {
     if (!fileName.endsWith(".md")) continue;
-    const abs = path64.join(dir, fileName);
-    if (!(await fs43.lstat(abs)).isFile()) continue;
+    const abs = path65.join(dir, fileName);
+    if (!(await fs44.lstat(abs)).isFile()) continue;
     const name = fileName.slice(0, -".md".length);
-    out.push({ type, name, sourceRelPath: path64.posix.join(".claude", subdir, fileName) });
+    out.push({ type, name, sourceRelPath: path65.posix.join(".claude", subdir, fileName) });
   }
   return out;
 }
@@ -9868,9 +10147,9 @@ async function collectSourceAssets(member) {
 
 // src/workspace/link-context/plan.ts
 function repoFolderPrefix(member) {
-  const base = path65.posix.basename(member.folder);
+  const base = path66.posix.basename(member.folder);
   if (base && base !== "." && base !== "/") return base;
-  const fromAbs = path65.basename(member.absPath);
+  const fromAbs = path66.basename(member.absPath);
   return fromAbs || member.id;
 }
 function assetKey(type, destKey) {
@@ -9885,7 +10164,7 @@ async function buildLinkPlan(members) {
   const byKey = /* @__PURE__ */ new Map();
   const membersById = new Map(members.map((m) => [m.id, m]));
   for (const member of members) {
-    if (!await fs44.pathExists(member.absPath)) {
+    if (!await fs45.pathExists(member.absPath)) {
       skipped.push({ repo: member.id, reason: `not cloned locally (${member.absPath}) \u2014 skipped` });
       continue;
     }
@@ -9927,7 +10206,7 @@ async function buildLinkPlan(members) {
       name: asset.name,
       destKey,
       sourceRelPath: asset.sourceRelPath,
-      sourceAbsPath: path65.join(member.absPath, asset.sourceRelPath),
+      sourceAbsPath: path66.join(member.absPath, asset.sourceRelPath),
       sourceHash
     });
   }
@@ -9938,7 +10217,7 @@ async function buildLinkPlan(members) {
 function destRelPathFor(type, destKey) {
   const subdir = `${type}s`;
   const leaf = type === "skill" ? destKey : `${destKey}.md`;
-  return path66.posix.join(".claude", subdir, leaf);
+  return path67.posix.join(".claude", subdir, leaf);
 }
 async function runLinkContext(workspaceRoot, opts = {}) {
   const write = opts.write ?? false;
@@ -9964,17 +10243,17 @@ async function runLinkContext(workspaceRoot, opts = {}) {
   const linkedAt = (/* @__PURE__ */ new Date()).toISOString();
   for (const entry of plan.entries) {
     const destRel = destRelPathFor(entry.type, entry.destKey);
-    const destAbs = path66.join(workspaceRoot, destRel);
+    const destAbs = path67.join(workspaceRoot, destRel);
     if (write) {
-      await fs45.ensureDir(path66.dirname(destAbs));
-      if (await fs45.pathExists(destAbs)) await fs45.remove(destAbs);
-      await fs45.copy(entry.sourceAbsPath, destAbs, {
+      await fs46.ensureDir(path67.dirname(destAbs));
+      if (await fs46.pathExists(destAbs)) await fs46.remove(destAbs);
+      await fs46.copy(entry.sourceAbsPath, destAbs, {
         overwrite: true,
         errorOnExist: false,
         dereference: false,
         filter: (s) => {
           try {
-            return !fs45.lstatSync(s).isSymbolicLink();
+            return !fs46.lstatSync(s).isSymbolicLink();
           } catch {
             return false;
           }
@@ -9998,8 +10277,12 @@ async function runLinkContext(workspaceRoot, opts = {}) {
     if (nextPaths.has(old.path)) continue;
     removed.push(old.path);
     if (write) {
-      const abs = path66.join(workspaceRoot, old.path);
-      if (await fs45.pathExists(abs)) await fs45.remove(abs);
+      const abs = resolveContainedPath(workspaceRoot, old.path);
+      if (abs === null) {
+        warn(`Refusing to remove linked context path outside the workspace root: ${old.path}`);
+        continue;
+      }
+      if (await fs46.pathExists(abs)) await fs46.remove(abs);
     }
   }
   if (write) {
@@ -10051,11 +10334,11 @@ async function runWorkspaceLinkContext(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync8, statSync } from "node:fs";
-import path68 from "node:path";
+import path69 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path67 from "node:path";
-import fs46 from "fs-extra";
+import path68 from "node:path";
+import fs47 from "fs-extra";
 var WORKSPACE_SENTINELS = { begin: WORKSPACE_BLOCK_BEGIN, end: WORKSPACE_BLOCK_END };
 function buildWorkspaceImportBlock(client, members) {
   const memberLines = members.map((m) => `- ${m.name} (${m.path})`);
@@ -10074,11 +10357,11 @@ ${WORKSPACE_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") : path67.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path68.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
-  const existed = await fs46.pathExists(filePath);
-  const prev = existed ? await fs46.readFile(filePath, "utf8") : "";
+  const existed = await fs47.pathExists(filePath);
+  const prev = existed ? await fs47.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block, WORKSPACE_SENTINELS);
   const printable = displayPath(workspaceRoot, filePath);
@@ -10105,20 +10388,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 
 // src/commands/workspace/setup.ts
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path68.resolve(start);
+  let dir = path69.resolve(start);
   for (; ; ) {
-    if (existsSync8(path68.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path68.dirname(dir);
-    if (parent === dir) return path68.resolve(start);
+    if (existsSync8(path69.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path69.dirname(dir);
+    if (parent === dir) return path69.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path68.resolve(workspaceRoot, repoPath) === path68.resolve(workspaceRoot);
+  return path69.resolve(workspaceRoot, repoPath) === path69.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path68.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path69.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -10145,7 +10428,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path68.resolve(workspaceRoot, repo.path);
+    const repoRoot = path69.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -10178,7 +10461,15 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
         status: "failed",
         error: message
       });
-      if (!options.continueOnError) throw err;
+      if (!options.continueOnError) {
+        if (options.json) {
+          const result2 = { workspaceRoot, statuses, written: [] };
+          log(JSON.stringify(result2, null, 2));
+          process.exitCode = 1;
+          return result2;
+        }
+        throw err;
+      }
       error(`Setup failed for ${repo.name}: ${message}`);
     }
   }
@@ -10227,7 +10518,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(path68.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path69.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -10283,7 +10574,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
     try {
       const linkResult = await runLinkContext(workspaceRoot, { write: true, json: options.json });
       if (linkResult.ok) {
-        written.push(...linkResult.added.map((rel) => path68.join(workspaceRoot, rel)));
+        written.push(...linkResult.added.map((rel) => path69.join(workspaceRoot, rel)));
         if (!options.json) {
           say(
             `Linked ${linkResult.linked.length} cross-repo skill/agent/command copy(ies) into .claude/ (${linkResult.added.length} new, ${linkResult.removed.length} removed)${linkResult.skipped.length > 0 ? ` \u2014 ${linkResult.skipped.length} member(s) skipped, see above` : ""}.`
@@ -10315,8 +10606,8 @@ Workspace setup complete: ${ok} ok, ${failed} failed. Wrote ${written.length} fi
 
 // src/commands/workspace/undo.ts
 import { existsSync as existsSync9, statSync as statSync2 } from "node:fs";
-import path69 from "node:path";
-import fs47 from "fs-extra";
+import path70 from "node:path";
+import fs48 from "fs-extra";
 var WORKSPACE_AGGREGATE_FILES = [
   "workspace-summary.json",
   "dependency-ownership-map.json",
@@ -10352,7 +10643,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   let anyRepoFailed = false;
   for (const repo of config.repos) {
-    const repoRoot = path69.resolve(workspaceRoot, repo.path);
+    const repoRoot = path70.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -10367,30 +10658,34 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   const linkedContext = await readLinkedContext(workspaceRoot);
   for (const entry of linkedContext) {
-    const abs = path69.join(workspaceRoot, entry.path);
-    if (await fs47.pathExists(abs)) {
-      await fs47.remove(abs);
+    const abs = resolveContainedPath(workspaceRoot, entry.path);
+    if (abs === null) {
+      warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
+      continue;
+    }
+    if (await fs48.pathExists(abs)) {
+      await fs48.remove(abs);
       log(`Removed ${entry.path} (linked ${entry.type} from ${entry.repo})`);
     }
   }
   for (const rel of WORKSPACE_AGGREGATE_FILES) {
     const abs = hausPath(workspaceRoot, rel);
-    if (await fs47.pathExists(abs)) {
-      await fs47.remove(abs);
-      log(`Removed ${path69.relative(workspaceRoot, abs)}`);
+    if (await fs48.pathExists(abs)) {
+      await fs48.remove(abs);
+      log(`Removed ${path70.relative(workspaceRoot, abs)}`);
     }
   }
   const manifestFile = manifestPath(workspaceRoot);
-  if (await fs47.pathExists(manifestFile)) {
-    await fs47.remove(manifestFile);
-    log(`Removed ${path69.relative(workspaceRoot, manifestFile)}`);
+  if (await fs48.pathExists(manifestFile)) {
+    await fs48.remove(manifestFile);
+    log(`Removed ${path70.relative(workspaceRoot, manifestFile)}`);
   }
   const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
-  if (await fs47.pathExists(workspaceMdPath)) {
-    await fs47.remove(workspaceMdPath);
-    log(`Removed ${path69.relative(workspaceRoot, workspaceMdPath)}`);
+  if (await fs48.pathExists(workspaceMdPath)) {
+    await fs48.remove(workspaceMdPath);
+    log(`Removed ${path70.relative(workspaceRoot, workspaceMdPath)}`);
   } else {
-    const claudeMdPath = path69.join(workspaceRoot, "CLAUDE.md");
+    const claudeMdPath = path70.join(workspaceRoot, "CLAUDE.md");
     if (existsSync9(claudeMdPath)) {
       const prev = await readText(claudeMdPath);
       if (prev?.includes(WORKSPACE_BLOCK_BEGIN)) {
@@ -10399,19 +10694,19 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
           end: WORKSPACE_BLOCK_END
         });
         if (next.length === 0) {
-          await fs47.remove(claudeMdPath);
+          await fs48.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the workspace haus import block).");
         } else {
-          await fs47.writeFile(claudeMdPath, next, "utf8");
+          await fs48.writeFile(claudeMdPath, next, "utf8");
           log("Removed haus import block from CLAUDE.md (user content preserved).");
         }
       } else if (prev && hasLegacyWorkspaceBlock(prev)) {
         const next = stripHausBlock(prev, { begin: BLOCK_BEGIN, end: BLOCK_END });
         if (next.length === 0) {
-          await fs47.remove(claudeMdPath);
+          await fs48.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the pre-upgrade workspace haus import block).");
         } else {
-          await fs47.writeFile(claudeMdPath, next, "utf8");
+          await fs48.writeFile(claudeMdPath, next, "utf8");
           log(
             "Removed pre-upgrade workspace haus import block from CLAUDE.md (user content preserved)."
           );
@@ -10442,7 +10737,16 @@ function normalizeMaxDepth(maxDepth) {
   warn(`Ignoring invalid --max-depth "${String(maxDepth)}"; using the default depth.`);
   return void 0;
 }
-async function initWorkspace() {
+async function initWorkspace(options = {}) {
+  if (existsSync10(WORKSPACE_FILE) && !options.yes) {
+    const ok = await confirm(
+      `${WORKSPACE_FILE} already exists \u2014 overwrite with a fresh placeholder? Existing client/repos/relationships will be lost. Run \`haus workspace discover\` instead to merge in newly found repos.`
+    );
+    if (!ok) {
+      log("Cancelled.");
+      return;
+    }
+  }
   await writeText(
     WORKSPACE_FILE,
     `client: unknown
@@ -10456,7 +10760,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path70.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path71.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -10478,7 +10782,7 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path70.resolve(workspaceRoot, repo.path);
+    const repoRoot = path71.resolve(workspaceRoot, repo.path);
     try {
       if (!existsSync10(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
@@ -10504,7 +10808,7 @@ async function scanWorkspace(workspaceRoot, opts) {
 }
 async function runWorkspace(action, options = {}) {
   if (action === "init") {
-    await initWorkspace();
+    await initWorkspace({ yes: options.yes });
     return;
   }
   const workspaceRoot = resolveWorkspaceRoot();
@@ -10544,7 +10848,7 @@ async function runWorkspace(action, options = {}) {
 // src/cli.ts
 function cliVersion() {
   try {
-    const pkgPath = path71.join(packageRoot(), "package.json");
+    const pkgPath = path72.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -10554,7 +10858,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path71.join(packageRoot(), "package.json");
+    const pkgPath = path72.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -10615,7 +10919,7 @@ program.command("install").option("--dry-run").option("--force").option("--check
 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."
 ).option("--force", "Overwrite existing files").option("--dry-run", "Preview what would be written without changing anything").option("--root <path>", "Project root (defaults to cwd)", process.cwd()).action(runScaffold);
-program.command("uninstall").option("--force").action(runUninstallCommand);
+program.command("uninstall").option("--force").option("-y, --yes", "Skip confirmation").action(runUninstallCommand);
 var guard = program.command("guard");
 guard.command("file-access").option("--from-hook").action((opts) => runGuard("file-access", opts));
 guard.command("bash").option("--from-hook").action((opts) => runGuard("bash", opts));
@@ -10632,7 +10936,7 @@ function registerDecisionsCommand(name) {
 registerDecisionsCommand("decisions");
 registerDecisionsCommand("adr");
 var workspace = program.command("workspace");
-workspace.command("init").action(() => runWorkspace("init"));
+workspace.command("init").option("-y, --yes", "Skip confirmation when haus.workspace.yaml already exists").action((opts) => runWorkspace("init", opts));
 workspace.command("discover").description("Auto-find member repos and write/merge haus.workspace.yaml").option("--write", "Persist haus.workspace.yaml (default previews only)").option("--json", "Output the discovered repos and proposed config as JSON").option("--max-depth <n>", "Max directory depth to traverse (default 3)").option("--client <name>", "Set the workspace client name").action((opts) => runWorkspace("discover", opts));
 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));