@haus-tech/haus-workflow 0.18.1 → 0.18.2

package/dist/cli.js

@@ -8,7 +8,7 @@ import { Command } from "commander";
 // src/commands/apply.ts
 import path13 from "path";
 import checkbox from "@inquirer/checkbox";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 
 // src/catalog/remote-catalog.ts
 import os from "os";
@@ -254,6 +254,13 @@ async function writeJson(file, value) {
   await fs2.writeFile(file, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
+async function pruneEmptyDir(dir) {
+  try {
+    const entries = await fs2.readdir(dir);
+    if (entries.length === 0) await fs2.remove(dir);
+  } catch {
+  }
+}
 async function readText(file) {
   try {
     return await fs2.readFile(file, "utf8");
@@ -647,7 +654,7 @@ async function applyProjectSettingsMerge(root) {
 
 // src/claude/write-claude-files.ts
 import path12 from "path";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 
 // src/catalog/load-catalog.ts
 import path6 from "path";
@@ -728,6 +735,22 @@ async function hashInstalledPaths(root, relPaths) {
   return hashText(fileDigests.map((f) => `${f.rel}=${f.digest}`).join("|"));
 }
 
+// src/claude/load-hooks-config.ts
+import path8 from "path";
+var CONFIG_PATH = ".haus-workflow/config.json";
+var DEFAULT_HOOKS_CONFIG = {
+  hooks: {
+    context: { enabled: false }
+  }
+};
+async function isHookEnabled(root, key) {
+  const cfg = await readJson(path8.join(root, CONFIG_PATH));
+  return cfg?.hooks?.[key]?.enabled === true;
+}
+
+// src/claude/managed-write.ts
+import fs5 from "fs-extra";
+
 // src/utils/diff.ts
 import { createTwoFilesPatch } from "diff";
 function hasTextChanged(before, after) {
@@ -750,21 +773,35 @@ function summarizeDiff(diffText) {
   return { additions, deletions };
 }
 
-// src/claude/load-hooks-config.ts
-import path8 from "path";
-var CONFIG_PATH = ".haus-workflow/config.json";
-var DEFAULT_HOOKS_CONFIG = {
-  hooks: {
-    context: { enabled: false }
+// src/claude/managed-write.ts
+async function writeManagedText(root, filePath, nextText, dryRun) {
+  const prev = await fs5.pathExists(filePath) ? await fs5.readFile(filePath, "utf8") : "";
+  const printable = displayPath(root, filePath);
+  if (dryRun) {
+    if (!prev) {
+      log(createUnifiedDiff(printable, "", nextText));
+    } else if (hasTextChanged(prev, nextText)) {
+      log(createUnifiedDiff(printable, prev, nextText));
+    } else {
+      log(`${printable}: unchanged`);
+    }
+    return;
   }
-};
-async function isHookEnabled(root, key) {
-  const cfg = await readJson(path8.join(root, CONFIG_PATH));
-  return cfg?.hooks?.[key]?.enabled === true;
+  if (hasTextChanged(prev, nextText) && prev.length > 0) {
+    const diffText = createUnifiedDiff(printable, prev, nextText);
+    const summary = summarizeDiff(diffText);
+    log(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
+  }
+  await writeText(filePath, nextText);
+}
+async function writeManagedJson(root, filePath, value, dryRun) {
+  const nextText = `${JSON.stringify(value, null, 2)}
+`;
+  await writeManagedText(root, filePath, nextText, dryRun);
 }
 
 // src/claude/verify-hooks-contract.ts
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 
 // src/claude/load-hooks.ts
 var CANONICAL_HOOKS = {
@@ -858,7 +895,7 @@ async function assertPostApplySettingsHausContract(root) {
 }
 async function verifyProjectSettingsHooksContract(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs5.pathExists(settingsPath)) {
+  if (!await fs6.pathExists(settingsPath)) {
     return {
       ok: true,
       skipped: true,
@@ -886,7 +923,7 @@ async function verifyProjectSettingsHooksContract(root) {
 
 // src/claude/write-root-claude-md.ts
 import path9 from "path";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
 var IMPORT_CONTENT = `@.haus-workflow/WORKFLOW.md
@@ -898,8 +935,9 @@ ${BLOCK_END}`;
 }
 function stripHausBlock(existing) {
   const beginIdx = existing.indexOf(BLOCK_BEGIN);
-  const endIdx = existing.indexOf(BLOCK_END);
-  if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) return existing;
+  if (beginIdx === -1) return existing;
+  const endIdx = existing.indexOf(BLOCK_END, beginIdx + BLOCK_BEGIN.length);
+  if (endIdx === -1) return existing;
   const before = existing.slice(0, beginIdx);
   const after = existing.slice(endIdx + BLOCK_END.length);
   const merged = `${before}${after}`.replace(/\n{3,}/g, "\n\n").trimEnd();
@@ -908,8 +946,8 @@ function stripHausBlock(existing) {
 }
 function injectHausBlock(existing, block) {
   const beginIdx = existing.indexOf(BLOCK_BEGIN);
-  const endIdx = existing.indexOf(BLOCK_END);
-  if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+  const endIdx = beginIdx === -1 ? -1 : existing.indexOf(BLOCK_END, beginIdx + BLOCK_BEGIN.length);
+  if (beginIdx !== -1 && endIdx !== -1) {
     const before = existing.slice(0, beginIdx);
     const after = existing.slice(endIdx + BLOCK_END.length);
     return `${before}${block}${after}`;
@@ -927,35 +965,19 @@ ${block}
 async function writeRootClaudeMd(root, dryRun) {
   const filePath = path9.join(root, "CLAUDE.md");
   const block = buildImportBlock();
-  const prev = await fs6.pathExists(filePath) ? await fs6.readFile(filePath, "utf8") : "";
+  const prev = await fs7.pathExists(filePath) ? await fs7.readFile(filePath, "utf8") : "";
   const next = injectHausBlock(prev, block);
-  const printable = displayPath(root, filePath);
-  if (dryRun) {
-    if (!prev) {
-      log(createUnifiedDiff(printable, "", next));
-    } else if (hasTextChanged(prev, next)) {
-      log(createUnifiedDiff(printable, prev, next));
-    } else {
-      log(`${printable}: unchanged`);
-    }
-    return filePath;
-  }
-  if (hasTextChanged(prev, next) && prev.length > 0) {
-    const diffText = createUnifiedDiff(printable, prev, next);
-    const summary = summarizeDiff(diffText);
-    log(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
-  }
-  await writeText(filePath, next);
+  await writeManagedText(root, filePath, next, dryRun);
   return filePath;
 }
 
 // src/claude/write-workflow-config.ts
 import path11 from "path";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 
 // src/claude/derive-workflow-config.ts
 import path10 from "path";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 function binCmd(pm, bin, args) {
   const tail = args ? ` ${args}` : "";
   if (pm === "yarn") return `yarn ${bin}${tail}`;
@@ -974,7 +996,7 @@ async function deriveWorkflowConfig(root, ctx) {
     return null;
   };
   const hasDep = (name) => deps.has(name);
-  const exists = (rel) => fs7.pathExistsSync(path10.join(root, rel));
+  const exists = (rel) => fs8.pathExistsSync(path10.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;
@@ -1043,7 +1065,7 @@ var FALLBACK_CONTEXT = {
 async function writeWorkflowConfig(root, dryRun, opts = {}) {
   const destPath = hausPath(root, "workflow-config.md");
   const printable = displayPath(root, destPath);
-  const exists = await fs8.pathExists(destPath);
+  const exists = await fs9.pathExists(destPath);
   if (exists && !opts.refill) {
     if (dryRun) log(printable + ": exists (project-owned, skipping)");
     return null;
@@ -1055,7 +1077,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   };
   const values = await deriveWorkflowConfig(root, ctx);
   if (exists) {
-    const current = await fs8.readFile(destPath, "utf8");
+    const current = await fs9.readFile(destPath, "utf8");
     const refilled = refillContent(current, values);
     if (refilled === current) {
       if (dryRun) log(printable + ": no blank fields to refill");
@@ -1077,7 +1099,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
 }
 
 // src/claude/write-workflow.ts
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 
 // src/claude/managed-template.ts
 function normaliseLF(content2) {
@@ -1110,8 +1132,8 @@ async function writeWorkflow(root, pkgVersion, dryRun) {
 ${templateContent}`;
   const destPath = hausPath(root, "WORKFLOW.md");
   const printable = displayPath(root, destPath);
-  if (await fs9.pathExists(destPath)) {
-    const existing = await fs9.readFile(destPath, "utf8");
+  if (await fs10.pathExists(destPath)) {
+    const existing = await fs10.readFile(destPath, "utf8");
     const firstLine = existing.split("\n")[0] ?? "";
     const parsed = parseHausManagedHeader(firstLine);
     if (!parsed) {
@@ -1133,7 +1155,7 @@ ${templateContent}`;
     }
   }
   if (dryRun) {
-    const prev = await fs9.pathExists(destPath) ? await fs9.readFile(destPath, "utf8") : "";
+    const prev = await fs10.pathExists(destPath) ? await fs10.readFile(destPath, "utf8") : "";
     if (!prev) {
       log(createUnifiedDiff(printable, "", next));
     } else {
@@ -1192,7 +1214,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     await assertPostApplySettingsHausContract(root);
   }
   const configPath = hausPath(root, "config.json");
-  if (!await fs10.pathExists(configPath)) {
+  if (!await fs11.pathExists(configPath)) {
     await writeManagedJson(root, configPath, DEFAULT_HOOKS_CONFIG, dryRun);
   }
   await writeManagedText(
@@ -1242,15 +1264,15 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     const sourcePath = catalogItemContentPath(contentRoot, manifestItem);
     const target = item.type === "agent" ? "agents" : item.type === "template" ? "templates" : item.type === "command" ? "commands" : "skills";
     const destination = claudePath(root, target, path12.basename(sourcePath));
-    if (await fs10.pathExists(sourcePath)) {
+    if (await fs11.pathExists(sourcePath)) {
       if (dryRun) {
-        const exists = await fs10.pathExists(destination);
+        const exists = await fs11.pathExists(destination);
         log(
           `${displayPath(root, destination)}: ${exists ? "would overwrite" : "would create"} (${item.id})`
         );
       } else {
-        await fs10.ensureDir(path12.dirname(destination));
-        await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+        await fs11.ensureDir(path12.dirname(destination));
+        await fs11.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
       const current = installedPathsByItem.get(item.id) ?? [];
@@ -1314,7 +1336,7 @@ async function cleanupStaleCatalogItems(root, knownIds, dryRun) {
     if (relPaths.length === 0) continue;
     const existing = [];
     for (const rel of relPaths) {
-      if (await fs10.pathExists(path12.join(root, rel))) existing.push(rel);
+      if (await fs11.pathExists(path12.join(root, rel))) existing.push(rel);
     }
     if (existing.length === 0) continue;
     if (entry.hash === void 0) {
@@ -1336,44 +1358,12 @@ async function cleanupStaleCatalogItems(root, knownIds, dryRun) {
         log(`[dry-run] would remove stale ${displayPath(root, abs)} (${entry.id})`);
         continue;
       }
-      await fs10.remove(abs);
+      await fs11.remove(abs);
       await pruneEmptyDir(path12.dirname(abs));
       log(`Removed stale ${displayPath(root, abs)} (${entry.id})`);
     }
   }
 }
-async function pruneEmptyDir(dir) {
-  try {
-    const entries = await fs10.readdir(dir);
-    if (entries.length === 0) await fs10.remove(dir);
-  } catch {
-  }
-}
-async function writeManagedText(root, filePath, nextText, dryRun) {
-  const prev = await fs10.pathExists(filePath) ? await fs10.readFile(filePath, "utf8") : "";
-  const printable = displayPath(root, filePath);
-  if (dryRun) {
-    if (!prev) {
-      log(createUnifiedDiff(printable, "", nextText));
-    } else if (hasTextChanged(prev, nextText)) {
-      log(createUnifiedDiff(printable, prev, nextText));
-    } else {
-      log(`${printable}: unchanged`);
-    }
-    return;
-  }
-  if (hasTextChanged(prev, nextText) && prev.length > 0) {
-    const diffText = createUnifiedDiff(printable, prev, nextText);
-    const summary = summarizeDiff(diffText);
-    log(`Overwriting ${printable} (diff +${summary.additions} -${summary.deletions})`);
-  }
-  await writeText(filePath, nextText);
-}
-async function writeManagedJson(root, filePath, value, dryRun) {
-  const nextText = `${JSON.stringify(value, null, 2)}
-`;
-  await writeManagedText(root, filePath, nextText, dryRun);
-}
 
 // src/commands/apply.ts
 async function cacheHasItems() {
@@ -1437,8 +1427,8 @@ async function runApply(options) {
   }
 }
 async function isHausProject(root) {
-  if (await fs11.pathExists(hausPath(root, "recommendation.json"))) return true;
-  if (await fs11.pathExists(claudePath(root, "settings.json"))) {
+  if (await fs12.pathExists(hausPath(root, "recommendation.json"))) return true;
+  if (await fs12.pathExists(claudePath(root, "settings.json"))) {
     const settings = await readProjectSettings(root);
     if (settings._haus != null) return true;
   }
@@ -2067,7 +2057,7 @@ function compareVersions(a, b) {
 
 // src/scanner/detect-package-manager.ts
 import path15 from "path";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -2085,9 +2075,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs12.existsSync(path15.join(root, "yarn.lock"))) return "yarn";
-  if (fs12.existsSync(path15.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs12.existsSync(path15.join(root, "package-lock.json"))) return "npm";
+  if (fs13.existsSync(path15.join(root, "yarn.lock"))) return "yarn";
+  if (fs13.existsSync(path15.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs13.existsSync(path15.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
@@ -2620,7 +2610,7 @@ async function runContext(options) {
 
 // src/commands/doctor.ts
 import path19 from "path";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 
 // src/update/npm-version.ts
 var NPM_PACKAGE_NAME = "@haus-tech/haus-workflow";
@@ -2728,7 +2718,7 @@ async function runDoctor(options) {
       const block = rootClaudeMdContent.slice(beginIdx, endIdx + BLOCK_END.length);
       const importTargets = [...block.matchAll(/@\.haus-workflow\/(\S+)/g)].map((m) => m[1]);
       for (const target of importTargets) {
-        if (!await fs13.pathExists(hausPath(root, target))) {
+        if (!await fs14.pathExists(hausPath(root, target))) {
           flag(
             `- CLAUDE.md import: @.haus-workflow/${target} does not resolve (run \`haus apply --write\`)`,
             `A file CLAUDE.md links to (${target}) is missing, so part of the guidance won't load`,
@@ -2739,7 +2729,7 @@ async function runDoctor(options) {
     }
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs13.pathExists(workflowPath);
+  const workflowExists = await fs14.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -2761,7 +2751,7 @@ async function runDoctor(options) {
         "templates",
         "agentic-workflow-standard.md"
       );
-      const templatePath = await fs13.pathExists(cachePath) ? cachePath : bundledPath;
+      const templatePath = await fs14.pathExists(cachePath) ? cachePath : bundledPath;
       const templateContent = await readText(templatePath);
       if (storedHashMatch && templateContent) {
         const currentHash = hashText(normaliseLF(templateContent));
@@ -2780,7 +2770,7 @@ async function runDoctor(options) {
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs13.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs14.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -2788,7 +2778,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs13.readFile(workflowConfigPath, "utf8");
+    const cfg = await fs14.readFile(workflowConfigPath, "utf8");
     const unfilled = cfg.split("\n").filter((l) => l.includes("<!-- fill in")).length;
     if (unfilled > 0) {
       flag(
@@ -2963,7 +2953,7 @@ async function runGuard(kind, _options) {
 
 // src/commands/init.ts
 import path20 from "path";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 
 // src/utils/prompts.ts
 import { stdin as input, stdout as output } from "process";
@@ -3186,7 +3176,8 @@ async function recommend(root, context) {
       (t) => context.warnings.join(" ").toLowerCase().includes(t.toLowerCase())
     );
     if (configSignal) push("config-signal-match", "config signal match", `warning:${configSignal}`);
-    const changedMatch = changedFiles.find((f) => f.includes(item.id.split(".").pop() ?? ""));
+    const idSegment = item.id.split(".").pop() ?? "";
+    const changedMatch = idSegment ? changedFiles.find((f) => f.includes(idSegment)) : void 0;
     if (changedMatch)
       push("changed-file-match", "changed file match", `changedFile:${changedMatch}`);
     const requiresAny = item.requiresAny ?? [];
@@ -3350,7 +3341,7 @@ async function runSetupProject(options) {
 async function runInit(options) {
   const root = process.cwd();
   const hausDir = path20.join(root, ".haus-workflow");
-  const alreadyInit = await fs14.pathExists(hausDir);
+  const alreadyInit = await fs15.pathExists(hausDir);
   if (alreadyInit) {
     log("Haus AI already initialized in this project.");
     log("Run `haus setup-project` to reconfigure.");
@@ -3363,7 +3354,7 @@ async function runInit(options) {
 // src/install/apply.ts
 import crypto2 from "crypto";
 import path21 from "path";
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 
 // src/install/header.ts
 var MD_PREFIX = "<!-- HAUS-MANAGED";
@@ -3452,7 +3443,7 @@ function hashContent(content2) {
 function sourceVersion() {
   try {
     const pkgPath = path21.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
@@ -3464,10 +3455,10 @@ function globalSrcDir() {
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
   const skillsDir = path21.join(srcDir, "skills");
-  if (fs15.pathExistsSync(skillsDir)) {
-    for (const skillName of fs15.readdirSync(skillsDir)) {
+  if (fs16.pathExistsSync(skillsDir)) {
+    for (const skillName of fs16.readdirSync(skillsDir)) {
       const skillFile = path21.join(skillsDir, skillName, "SKILL.md");
-      if (fs15.pathExistsSync(skillFile)) {
+      if (fs16.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
           srcRelPath: path21.join("library", "global", "skills", skillName, "SKILL.md"),
@@ -3477,8 +3468,8 @@ function collectSourceFiles(srcDir, claudeDir) {
     }
   }
   const commandsDir = path21.join(srcDir, "commands");
-  if (fs15.pathExistsSync(commandsDir)) {
-    for (const fileName of fs15.readdirSync(commandsDir)) {
+  if (fs16.pathExistsSync(commandsDir)) {
+    for (const fileName of fs16.readdirSync(commandsDir)) {
       if (!fileName.endsWith(".md")) continue;
       const commandName = fileName.slice(0, -".md".length);
       entries.push({
@@ -3528,7 +3519,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs15.pathExistsSync(entry.destPath);
+    const destExists = fs16.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -3575,13 +3566,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 (!fs15.pathExistsSync(entry.destPath)) continue;
+      if (!fs16.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 fs15.remove(entry.destPath);
+        if (!dryRun) await fs16.remove(entry.destPath);
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -3709,7 +3700,7 @@ async function runScan(options) {
 
 // src/commands/undo.ts
 import path22 from "path";
-import fs16 from "fs-extra";
+import fs17 from "fs-extra";
 
 // src/claude/managed-paths.ts
 var PROJECT_MANAGED_CLAUDE_REL = [
@@ -3740,25 +3731,25 @@ async function collectManagedPaths(root) {
   }
   const existing = [];
   for (const abs of paths) {
-    if (await fs16.pathExists(abs)) existing.push(abs);
+    if (await fs17.pathExists(abs)) existing.push(abs);
   }
   return existing;
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs16.pathExists(settingsPath)) return false;
+  if (!await fs17.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
   const filePath = path22.join(root, "CLAUDE.md");
-  if (!await fs16.pathExists(filePath)) return false;
-  const text = await fs16.readFile(filePath, "utf8");
+  if (!await fs17.pathExists(filePath)) return false;
+  const text = await fs17.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs16.pathExists(settingsPath)) return false;
+  if (!await fs17.pathExists(settingsPath)) return false;
   let settings = await readProjectSettings(root);
   settings = stripHausAllow(stripHausDeny(stripHausHooks(settings)));
   const hasContent = Object.keys(settings).length > 0;
@@ -3767,29 +3758,29 @@ async function stripProjectSettings(root) {
     log(`Stripped haus rules from ${path22.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs16.remove(settingsPath);
+  await fs17.remove(settingsPath);
   log(`Removed ${path22.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
   const filePath = path22.join(root, "CLAUDE.md");
-  if (!await fs16.pathExists(filePath)) return false;
-  const prev = await fs16.readFile(filePath, "utf8");
+  if (!await fs17.pathExists(filePath)) return false;
+  const prev = await fs17.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs16.remove(filePath);
+    await fs17.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs16.writeFile(filePath, next, "utf8");
+    await fs17.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs16.pathExists(dir)) return;
-  const entries = await fs16.readdir(dir);
-  if (entries.length === 0) await fs16.remove(dir);
+  if (!await fs17.pathExists(dir)) return;
+  const entries = await fs17.readdir(dir);
+  if (entries.length === 0) await fs17.remove(dir);
 }
 async function runUndo(options) {
   const root = process.cwd();
@@ -3816,8 +3807,8 @@ User-owned .claude/ files will be preserved.`
     }
   }
   for (const abs of managed) {
-    if (!await fs16.pathExists(abs)) continue;
-    await fs16.remove(abs);
+    if (!await fs17.pathExists(abs)) continue;
+    await fs17.remove(abs);
     log(`Removed ${path22.relative(root, abs)}`);
   }
   if (stripSettings) await stripProjectSettings(root);
@@ -3830,7 +3821,7 @@ User-owned .claude/ files will be preserved.`
 // src/install/uninstall.ts
 import crypto3 from "crypto";
 import path23 from "path";
-import fs17 from "fs-extra";
+import fs18 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
   const manifest = await readManifest();
@@ -3840,7 +3831,7 @@ async function runUninstall(options = {}) {
     return result;
   }
   for (const entry of manifest.files) {
-    const exists = fs17.pathExistsSync(entry.destPath);
+    const exists = fs18.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -3858,8 +3849,8 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs17.remove(entry.destPath);
-    await pruneEmptyDir2(path23.dirname(entry.destPath));
+    await fs18.remove(entry.destPath);
+    await pruneEmptyDir(path23.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
   const settings = await readSettings();
@@ -3868,12 +3859,12 @@ async function runUninstall(options = {}) {
   result.hooksStripped = true;
   const hausDir = path23.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs17.pathExistsSync(manifestPath2)) {
-    await fs17.remove(manifestPath2);
+  if (fs18.pathExistsSync(manifestPath2)) {
+    await fs18.remove(manifestPath2);
   }
-  if (fs17.pathExistsSync(hausDir)) {
-    const remaining = await fs17.readdir(hausDir);
-    if (remaining.length === 0) await fs17.remove(hausDir);
+  if (fs18.pathExistsSync(hausDir)) {
+    const remaining = await fs18.readdir(hausDir);
+    if (remaining.length === 0) await fs18.remove(hausDir);
   }
   return result;
 }
@@ -3890,13 +3881,6 @@ function printUninstallResult(result) {
     log("Haus hook entries removed from ~/.claude/settings.json");
   }
 }
-async function pruneEmptyDir2(dir) {
-  try {
-    const entries = await fs17.readdir(dir);
-    if (entries.length === 0) await fs17.remove(dir);
-  } catch {
-  }
-}
 
 // src/commands/uninstall.ts
 async function runUninstallCommand(options) {
@@ -4110,7 +4094,7 @@ async function detectGlobalInstallDrift() {
 }
 
 // src/commands/validate-catalog.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path26 from "path";
 
 // src/catalog/forbidden-content.ts
@@ -4129,13 +4113,14 @@ function extractUseWhenSection(text) {
 function isYamlBlockScalarHeader(rest) {
   return /^[>|][-+]?(\d+)?(?:\s+#.*)?$/.test(rest);
 }
-function extractFrontmatterDescription(text) {
+function extractFrontmatterValue(text, key) {
   const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!m) return "";
   const lines = m[1].split(/\r?\n/);
-  const idx = lines.findIndex((l) => /^description:[ \t]*/.test(l));
+  const keyRe = new RegExp(`^${escapeRegExp(key)}:[ \\t]*`);
+  const idx = lines.findIndex((l) => keyRe.test(l));
   if (idx < 0) return "";
-  const rest = lines[idx].replace(/^description:[ \t]*/, "").trim();
+  const rest = lines[idx].replace(keyRe, "").trim();
   if (!rest) return "";
   if (!isYamlBlockScalarHeader(rest)) {
     return rest.replace(/^["']|["']$/g, "").trim();
@@ -4150,6 +4135,9 @@ function extractFrontmatterDescription(text) {
   }
   return body.join(" ").replace(/\s+/g, " ").trim();
 }
+function extractFrontmatterDescription(text) {
+  return extractFrontmatterValue(text, "description");
+}
 function auditForbiddenTagsInText(text, label) {
   const body = `${extractFrontmatterDescription(text)}
 ${extractUseWhenSection(text)}`;
@@ -4226,6 +4214,15 @@ function auditManifestStructure(items) {
   }
   return failures;
 }
+function checkRequiredFrontmatter(text, label) {
+  const failures = [];
+  for (const key of REQUIRED_SKILL_FRONTMATTER) {
+    if (!extractFrontmatterValue(text, key)) {
+      failures.push(`${label}: missing non-empty frontmatter '${key}:'`);
+    }
+  }
+  return failures;
+}
 function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
@@ -4233,26 +4230,21 @@ function auditShippedFiles(manifestDir, items) {
     const absPath = path26.join(manifestDir, item.path);
     if (item.type === "skill") {
       const skillMd = path26.join(absPath, "SKILL.md");
-      if (!fs18.existsSync(skillMd)) {
+      if (!fs19.existsSync(skillMd)) {
         failures.push(`${item.id}: missing ${path26.relative(manifestDir, skillMd)}`);
         continue;
       }
-      const text = fs18.readFileSync(skillMd, "utf8");
-      const description = extractFrontmatterDescription(text);
-      for (const key of REQUIRED_SKILL_FRONTMATTER) {
-        if (key === "description" && !description) {
-          failures.push(`${item.id}: SKILL.md missing non-empty frontmatter 'description:'`);
-        }
-      }
+      const text = fs19.readFileSync(skillMd, "utf8");
+      failures.push(...checkRequiredFrontmatter(text, `${item.id}: SKILL.md`));
       failures.push(
         ...auditForbiddenTagsInText(text, `${item.id}: ${path26.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs18.existsSync(absPath)) {
+      if (!fs19.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const text = fs18.readFileSync(absPath, "utf8");
+      const text = fs19.readFileSync(absPath, "utf8");
       if (!text.startsWith("---")) failures.push(`${item.id}: agent file missing YAML frontmatter`);
       for (const section of REQUIRED_AGENT_SECTIONS) {
         if (!text.includes(section)) failures.push(`${item.id}: agent file missing ${section}`);
@@ -4266,16 +4258,19 @@ function auditShippedFiles(manifestDir, items) {
         ...auditForbiddenTagsInText(text, `${item.id}: ${path26.relative(manifestDir, absPath)}`)
       );
     } else if (item.type === "template") {
-      if (!fs18.existsSync(absPath)) {
+      if (!fs19.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 (!fs18.existsSync(absPath)) {
+      if (!fs19.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
+      const text = fs19.readFileSync(absPath, "utf8");
+      const rel = path26.relative(manifestDir, absPath);
+      failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditTemplateContent(manifestDir, absPath, item.id));
     }
   }
@@ -4283,7 +4278,7 @@ function auditShippedFiles(manifestDir, items) {
 }
 function auditTemplateContent(manifestDir, absPath, itemId) {
   const rel = path26.relative(manifestDir, absPath);
-  const text = fs18.readFileSync(absPath, "utf8");
+  const text = fs19.readFileSync(absPath, "utf8");
   const failures = [];
   const lines = text.split(/\r?\n/);
   for (let i = 0; i < lines.length; i++) {
@@ -4306,9 +4301,9 @@ function auditMarkdownContent(manifestDir) {
   const dirs = ["skills", "agents", "templates", "commands"];
   for (const dir of dirs) {
     const abs = path26.join(manifestDir, dir);
-    if (!fs18.existsSync(abs)) continue;
+    if (!fs19.existsSync(abs)) continue;
     walkMd(abs, (file) => {
-      const text = fs18.readFileSync(file, "utf8");
+      const text = fs19.readFileSync(file, "utf8");
       const rel = path26.relative(manifestDir, file);
       const lines = text.split(/\r?\n/);
       for (let i = 0; i < lines.length; i++) {
@@ -4328,7 +4323,7 @@ function auditMarkdownContent(manifestDir) {
   return failures;
 }
 function walkMd(dir, fn) {
-  for (const entry of fs18.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs19.readdirSync(dir, { withFileTypes: true })) {
     const full = path26.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn);
     else if (entry.name.endsWith(".md")) fn(full);
@@ -4731,7 +4726,7 @@ import path32 from "path";
 
 // src/claude/write-workspace-claude-md.ts
 import path31 from "path";
-import fs19 from "fs-extra";
+import fs20 from "fs-extra";
 function buildWorkspaceImportBlock(client, members) {
   const memberLines = members.map((m) => `- ${m.name} (${m.path})`);
   const body = [
@@ -4750,7 +4745,7 @@ 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") : path31.join(workspaceRoot, "CLAUDE.md");
-  const prev = await fs19.pathExists(filePath) ? await fs19.readFile(filePath, "utf8") : "";
+  const prev = await fs20.pathExists(filePath) ? await fs20.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block);
   const printable = displayPath(workspaceRoot, filePath);