@haus-tech/haus-workflow 0.26.1 → 0.27.1

package/dist/cli.js

@@ -2,13 +2,12 @@
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "fs";
-import path34 from "path";
+import path35 from "path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
 import path13 from "path";
 import checkbox from "@inquirer/checkbox";
-import fs13 from "fs-extra";
 
 // src/catalog/remote-catalog.ts
 import os from "os";
@@ -20,17 +19,44 @@ import crypto from "crypto";
 import path from "path";
 import fg from "fast-glob";
 import fs from "fs-extra";
-async function readJson(file) {
+var MalformedJsonFileError = class extends Error {
+  constructor(filePath, backupPath) {
+    super(`Refusing to modify ${filePath}: invalid JSON. Backup written to ${backupPath}`);
+    this.filePath = filePath;
+    this.backupPath = backupPath;
+  }
+  filePath;
+  backupPath;
+  name = "MalformedJsonFileError";
+};
+async function readJsonDetailed(file) {
   try {
-    return await fs.readJson(file);
-  } catch {
-    return void 0;
+    if (!await fs.pathExists(file)) return { status: "missing" };
+    const raw = await fs.readFile(file, "utf8");
+    try {
+      return { status: "ok", value: JSON.parse(raw) };
+    } catch (error2) {
+      return { status: "invalid", error: error2 };
+    }
+  } catch (error2) {
+    if (error2.code === "ENOENT") return { status: "missing" };
+    throw error2;
   }
 }
+async function backupMalformedJsonFile(file) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${file}.haus-malformed-${stamp}.bak`;
+  await fs.copy(file, backupPath);
+  return backupPath;
+}
+async function readJson(file) {
+  const result = await readJsonDetailed(file);
+  if (result.status === "ok") return result.value;
+  return void 0;
+}
 async function writeJson(file, value) {
-  await fs.ensureDir(path.dirname(file));
-  await fs.writeFile(file, `${JSON.stringify(value, null, 2)}
-`, "utf8");
+  await atomicWriteText(file, `${JSON.stringify(value, null, 2)}
+`);
 }
 async function pruneEmptyDir(dir) {
   try {
@@ -47,8 +73,17 @@ async function readText(file) {
   }
 }
 async function writeText(file, value) {
-  await fs.ensureDir(path.dirname(file));
-  await fs.writeFile(file, value, "utf8");
+  await atomicWriteText(file, value);
+}
+async function atomicWriteText(file, value) {
+  const dir = path.dirname(file);
+  await fs.ensureDir(dir);
+  const tempPath = path.join(
+    dir,
+    `.tmp-haus-write-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  );
+  await fs.writeFile(tempPath, value, "utf8");
+  await fs.move(tempPath, file, { overwrite: true });
 }
 async function listFiles(root, patterns) {
   const files = await fg(patterns, {
@@ -85,7 +120,7 @@ var error = (msg, ...args) => {
 };
 
 // src/catalog/constants.ts
-var CATALOG_REPO_URL = "https://raw.githubusercontent.com/wearehaustech/haus-workflow-catalog";
+var CATALOG_REPO_URL = "https://raw.githubusercontent.com/WeAreHausTech/haus-workflow-catalog";
 var CATALOG_GITHUB_API_URL = "https://api.github.com/repos/WeAreHausTech/haus-workflow-catalog";
 var SUPERPOWERS_SHARED_CATALOG_REL = "skills/superpowers/shared";
 var CATALOG_REF = process.env.HAUS_CATALOG_REF;
@@ -342,6 +377,21 @@ var POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constru
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+var REQUIRES_ANY_KEYS = ["stack", "dependency", "packageNamePattern", "role"];
+function isRequiresAnyClause(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 1) return false;
+  const key = keys[0];
+  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;
@@ -400,6 +450,18 @@ function parseManifest(json) {
         return { ok: false, error: `${item.id}: curated item missing riskLevel` };
       }
     }
+    if (!isStringArray(item.tags)) {
+      return { ok: false, error: `${item.id}: tags must be a string array` };
+    }
+    if (!isStringArray(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 (typeof item.tokenEstimate !== "number" || !Number.isFinite(item.tokenEstimate)) {
+      return { ok: false, error: `${item.id}: tokenEstimate must be a finite number` };
+    }
     items.push(raw);
   }
   return { ok: true, manifest: { version: root.version, items } };
@@ -818,6 +880,17 @@ async function syncRemoteCatalog() {
   return { newItems, refreshed, unchanged, failed };
 }
 var CATALOG_TAGS_API_URL = "https://api.github.com/repos/WeAreHausTech/haus-workflow-catalog/tags";
+function parseSemverTag(tag) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(tag);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(a, b) {
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return 0;
+}
 async function fetchLatestCatalogTag() {
   if (process.env["HAUS_CATALOG_REMOTE_BASE"]) return null;
   try {
@@ -827,7 +900,16 @@ async function fetchLatestCatalogTag() {
     });
     if (!res.ok) return null;
     const tags = await res.json();
-    return tags[0]?.name ?? null;
+    const valid = tags.map((tag) => {
+      const name = typeof tag.name === "string" ? tag.name : "";
+      const semver2 = parseSemverTag(name);
+      return semver2 ? { name, semver: semver2 } : null;
+    }).filter(
+      (entry) => entry !== null
+    );
+    if (valid.length === 0) return null;
+    valid.sort((a, b) => compareSemver(b.semver, a.semver));
+    return valid[0].name;
   } catch {
     return null;
   }
@@ -841,6 +923,226 @@ async function getCacheManifestAge() {
   }
 }
 
+// src/claude/write-claude-files.ts
+import path12 from "path";
+import fs12 from "fs-extra";
+
+// src/catalog/load-catalog.ts
+import path4 from "path";
+
+// src/utils/paths.ts
+import { existsSync, readFileSync } from "fs";
+import os2 from "os";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var HAUS_DIR = ".haus-workflow";
+function hausPath(root, ...parts) {
+  return path3.join(root, HAUS_DIR, ...parts);
+}
+function claudePath(root, ...parts) {
+  return path3.join(root, ".claude", ...parts);
+}
+function displayPath(root, targetPath) {
+  const rel = path3.relative(root, targetPath).replace(/\\/g, "/");
+  if (rel && !rel.startsWith("../") && rel !== "..") {
+    return rel.startsWith("./") ? rel : `./${rel}`;
+  }
+  const home = os2.homedir();
+  const normalized = targetPath.replace(/\\/g, "/");
+  if (home && home.trim().length > 0) {
+    const homeRel = path3.relative(home, targetPath).replace(/\\/g, "/");
+    if (homeRel && !homeRel.startsWith("../") && homeRel !== "..") {
+      return `~/${homeRel}`;
+    }
+  }
+  return normalized;
+}
+function packageRoot() {
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = path3.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "haus" || pkg.name === "@haus-tech/haus-workflow") return dir;
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const file = fileURLToPath(import.meta.url);
+  return path3.resolve(path3.dirname(file), "../..");
+}
+
+// src/catalog/load-catalog.ts
+async function loadCatalogContext(root) {
+  const envPath = process.env["HAUS_FIXTURE_CATALOG"];
+  if (envPath) {
+    const data2 = await readJson(envPath);
+    return {
+      items: data2?.items ?? [],
+      contentRoot: path4.dirname(envPath),
+      source: "fixture"
+    };
+  }
+  const cacheDir = getCacheDir();
+  const cacheManifestPath = path4.join(cacheDir, "manifest.json");
+  const cacheData = await readJson(cacheManifestPath);
+  if (cacheData?.items?.length) {
+    return { items: cacheData.items, contentRoot: cacheDir, source: "cache" };
+  }
+  const localManifest = path4.join(root, "library/catalog/manifest.json");
+  const localData = await readJson(localManifest);
+  if (localData?.items?.length) {
+    return {
+      items: localData.items,
+      contentRoot: path4.dirname(localManifest),
+      source: "local"
+    };
+  }
+  const packageManifest = path4.join(packageRoot(), "library/catalog/manifest.json");
+  const data = await readJson(packageManifest);
+  return {
+    items: data?.items ?? [],
+    contentRoot: path4.dirname(packageManifest),
+    source: "bundled"
+  };
+}
+async function loadCatalog(root) {
+  const ctx = await loadCatalogContext(root);
+  return ctx.items;
+}
+function catalogItemContentPath(contentRoot, item) {
+  return path4.join(contentRoot, item.path);
+}
+
+// src/update/hash-installed.ts
+import path5 from "path";
+import fg2 from "fast-glob";
+import fs3 from "fs-extra";
+
+// src/claude/haus-managed-header.ts
+function parseHausManagedAttrs(line2) {
+  const match = /^<!--\s+HAUS-MANAGED\b(.*?)-->$/.exec(line2.trim());
+  if (!match) return null;
+  const raw = match[1] ?? "";
+  const pairs = [...raw.matchAll(/\b([a-z]+)=([^\s>]+)/g)];
+  const attrs = {};
+  for (const [, key, value] of pairs) attrs[key] = value;
+  if (!attrs.id) return null;
+  return {
+    id: attrs.id,
+    v: attrs.v,
+    source: attrs.source,
+    hash: attrs.hash
+  };
+}
+
+// src/claude/managed-template.ts
+function normaliseLF(content2) {
+  return content2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+var SCHEMA_VERSION = 1;
+function parseHausManagedHeader(line2) {
+  const attrs = parseHausManagedAttrs(line2);
+  if (!attrs?.id) return null;
+  const parsedV = attrs.v && /^\d+$/.test(attrs.v) ? Number(attrs.v) : void 0;
+  const hash = attrs.hash && /^sha256-[a-f0-9]+$/.test(attrs.hash) ? attrs.hash : void 0;
+  return {
+    id: attrs.id,
+    v: parsedV,
+    source: attrs.source,
+    hash
+  };
+}
+
+// src/update/hash-installed.ts
+var EMPTY_LOCK_PATHS_TOKEN = "haus-lock:empty-paths";
+async function hashInstalledPaths(root, relPaths) {
+  if (relPaths.length === 0) {
+    return hashText(EMPTY_LOCK_PATHS_TOKEN);
+  }
+  const normalized = [...new Set(relPaths.map((p) => p.replace(/\\/g, "/")))].sort();
+  const fileDigests = [];
+  for (const rel of normalized) {
+    const abs = path5.join(root, rel);
+    if (!await fs3.pathExists(abs)) continue;
+    const stat = await fs3.stat(abs);
+    if (stat.isFile()) {
+      const body = await fs3.readFile(abs, "utf8");
+      fileDigests.push({ rel, digest: hashText(normaliseLF(body)) });
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const inner = await fg2("**/*", { cwd: abs, onlyFiles: true, dot: true });
+    for (const sub of inner.sort()) {
+      const relFile = path5.join(rel, sub).replace(/\\/g, "/");
+      const absFile = path5.join(abs, sub);
+      const body = await fs3.readFile(absFile, "utf8");
+      fileDigests.push({ rel: relFile, digest: hashText(normaliseLF(body)) });
+    }
+  }
+  if (fileDigests.length === 0) {
+    return hashText(`${EMPTY_LOCK_PATHS_TOKEN}|${normalized.join("|")}`);
+  }
+  fileDigests.sort((a, b) => a.rel.localeCompare(b.rel));
+  return hashText(fileDigests.map((f) => `${f.rel}=${f.digest}`).join("|"));
+}
+
+// src/claude/managed-write.ts
+import fs4 from "fs-extra";
+
+// src/utils/diff.ts
+import { createTwoFilesPatch } from "diff";
+function hasTextChanged(before, after) {
+  return before !== after;
+}
+function createUnifiedDiff(filePath, before, after) {
+  return createTwoFilesPatch(filePath, filePath, before, after, "before", "after", {
+    context: 3
+  });
+}
+function summarizeDiff(diffText) {
+  const lines = diffText.split("\n");
+  let additions = 0;
+  let deletions = 0;
+  for (const line2 of lines) {
+    if (line2.startsWith("+++ ") || line2.startsWith("--- ")) continue;
+    if (line2.startsWith("+")) additions += 1;
+    if (line2.startsWith("-")) deletions += 1;
+  }
+  return { additions, deletions };
+}
+
+// src/claude/managed-write.ts
+async function writeManagedText(root, filePath, nextText, dryRun) {
+  const prev = await fs4.pathExists(filePath) ? await fs4.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/install/allow-rules.ts
 var ALLOWED_SUBCOMMANDS = ["setup-project", "apply", "doctor", "scan", "recommend"];
 function buildAllowRules() {
@@ -848,18 +1150,18 @@ function buildAllowRules() {
 }
 
 // src/install/settings-merge.ts
-import path4 from "path";
-import fs3 from "fs-extra";
+import path7 from "path";
+import fs5 from "fs-extra";
 
 // src/install/manifest.ts
-import os2 from "os";
-import path3 from "path";
+import os3 from "os";
+import path6 from "path";
 var MANIFEST_SCHEMA = "haus-install-manifest/1";
 function globalClaudeDir() {
-  return path3.join(os2.homedir(), ".claude");
+  return path6.join(os3.homedir(), ".claude");
 }
 function hausManifestPath() {
-  return path3.join(globalClaudeDir(), "haus", "install-manifest.json");
+  return path6.join(globalClaudeDir(), "haus", "install-manifest.json");
 }
 async function readManifest() {
   return readJson(hausManifestPath());
@@ -879,11 +1181,15 @@ function buildManifest(source, files, hooks) {
 
 // src/install/settings-merge.ts
 function settingsJsonPath() {
-  return path4.join(globalClaudeDir(), "settings.json");
+  return path7.join(globalClaudeDir(), "settings.json");
 }
 async function readSettings() {
-  const parsed = await readJson(settingsJsonPath());
-  return parsed ?? {};
+  const filePath = settingsJsonPath();
+  const result = await readJsonDetailed(filePath);
+  if (result.status === "ok") return result.value;
+  if (result.status === "missing") return {};
+  const backupPath = await backupMalformedJsonFile(filePath);
+  throw new MalformedJsonFileError(filePath, backupPath);
 }
 async function writeSettings(settings) {
   await writeJson(settingsJsonPath(), settings);
@@ -897,6 +1203,14 @@ function collectEventHookCommands(entries) {
   }
   return cmds;
 }
+function pruneEntryCommands(entry, shouldDrop) {
+  const keptHooks = (entry.hooks ?? []).filter((hook) => {
+    const cmd = hook.command ?? "";
+    return !cmd || !shouldDrop(cmd);
+  });
+  if (keptHooks.length === 0) return null;
+  return { ...entry, hooks: keptHooks };
+}
 var RETIRED_HAUS_HOOK_COMMANDS = ["haus context --from-hook"];
 var RETIRED_HAUS_HOOK_IDS = ["hook.context", "haus.context-hook"];
 function reconcileRetiredHausHooks(updated, fragments, priorHaus, addedIds, addedCommands) {
@@ -910,10 +1224,7 @@ function reconcileRetiredHausHooks(updated, fragments, priorHaus, addedIds, adde
   }
   const prunedHooks = {};
   for (const [event, entries] of Object.entries(updated.hooks ?? {})) {
-    const kept = entries.filter((entry) => {
-      const cmds = (entry.hooks ?? []).map((h) => h.command).filter(Boolean);
-      return cmds.length === 0 || !cmds.some((cmd) => retiredCommands.has(cmd));
-    });
+    const kept = entries.map((entry) => pruneEntryCommands(entry, (cmd) => retiredCommands.has(cmd))).filter((entry) => entry !== null);
     if (kept.length > 0) prunedHooks[event] = kept;
   }
   updated.hooks = prunedHooks;
@@ -1064,10 +1375,12 @@ function stripHausHooks(settings) {
   const updated = { ...settings };
   updated.hooks = {};
   for (const [event, entries] of Object.entries(settings.hooks ?? {})) {
-    const kept = entries.filter((entry) => {
-      const cmd = entry.hooks[0]?.command ?? "";
-      return usePrefix ? !cmd.startsWith("haus ") : !ownedCommands.has(cmd);
-    });
+    const kept = entries.map(
+      (entry) => pruneEntryCommands(
+        entry,
+        (cmd) => usePrefix ? cmd.startsWith("haus ") : ownedCommands.has(cmd)
+      )
+    ).filter((entry) => entry !== null);
     if (kept.length > 0) updated.hooks[event] = kept;
   }
   const { _haus: _, ...rest } = updated;
@@ -1113,7 +1426,7 @@ function stripHausAsk(settings) {
 async function loadHooksFragment(fragmentPath) {
   let raw;
   try {
-    raw = await fs3.readJson(fragmentPath);
+    raw = await fs5.readJson(fragmentPath);
   } catch {
     return [];
   }
@@ -1126,6 +1439,8 @@ var DENY_COMMANDS = [
   "sudo",
   "chmod -R 777",
   "git push --force",
+  "git push --force-with-lease",
+  "git push -f",
   "drop database",
   "truncate table",
   "npm publish",
@@ -1153,6 +1468,20 @@ var DENY_PATHS = [
   "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"] },
@@ -1190,275 +1519,77 @@ var SENSITIVE_ITEM_KEYWORDS = [
   ".pem",
   ".key"
 ];
-
-// src/security/ask-rules.ts
-function buildAskRules() {
-  const rules = [];
-  for (const command of ASK_COMMANDS) {
-    rules.push(`Bash(${command}:*)`);
-  }
-  for (const { pattern, tools } of ASK_PATHS) {
-    for (const tool of tools) {
-      rules.push(`${tool}(${pattern})`);
-    }
-  }
-  return [...new Set(rules)];
-}
-
-// src/security/deny-rules.ts
-var FILE_TOOLS = ["Read", "Edit", "Write"];
-function buildDenyRules() {
-  const rules = [];
-  for (const command of DENY_COMMANDS) {
-    rules.push(`Bash(${command}:*)`);
-  }
-  for (const path35 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path35) ? `${path35}/**` : path35;
-    for (const tool of FILE_TOOLS) {
-      rules.push(`${tool}(${pattern})`);
-    }
-  }
-  return [...new Set(rules)];
-}
-
-// src/utils/paths.ts
-import { existsSync, readFileSync } from "fs";
-import os3 from "os";
-import path5 from "path";
-import { fileURLToPath } from "url";
-var HAUS_DIR = ".haus-workflow";
-function hausPath(root, ...parts) {
-  return path5.join(root, HAUS_DIR, ...parts);
-}
-function claudePath(root, ...parts) {
-  return path5.join(root, ".claude", ...parts);
-}
-function displayPath(root, targetPath) {
-  const rel = path5.relative(root, targetPath).replace(/\\/g, "/");
-  if (rel && !rel.startsWith("../") && rel !== "..") {
-    return rel.startsWith("./") ? rel : `./${rel}`;
-  }
-  const home = os3.homedir();
-  const normalized = targetPath.replace(/\\/g, "/");
-  if (home && home.trim().length > 0) {
-    const homeRel = path5.relative(home, targetPath).replace(/\\/g, "/");
-    if (homeRel && !homeRel.startsWith("../") && homeRel !== "..") {
-      return `~/${homeRel}`;
-    }
-  }
-  return normalized;
-}
-function packageRoot() {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 12; i++) {
-    const pkgPath = path5.join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        if (pkg.name === "haus" || pkg.name === "@haus-tech/haus-workflow") return dir;
-      } catch {
-      }
-    }
-    const parent = path5.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  const file = fileURLToPath(import.meta.url);
-  return path5.resolve(path5.dirname(file), "../..");
-}
-
-// src/claude/merge-project-settings.ts
-var PROJECT_HOOK_FRAGMENTS = [
-  {
-    id: "haus.guard-file",
-    gate: "keep",
-    event: "PreToolUse",
-    matcher: "Read|Edit|Write",
-    command: "haus guard file-access --from-hook"
-  },
-  {
-    id: "haus.guard-bash",
-    gate: "keep",
-    event: "PreToolUse",
-    matcher: "Bash",
-    command: "haus guard bash --from-hook"
-  }
-];
-async function readProjectSettings(root) {
-  const parsed = await readJson(claudePath(root, "settings.json"));
-  return parsed ?? {};
-}
-async function writeProjectSettings(root, settings) {
-  await writeJson(claudePath(root, "settings.json"), settings);
-}
-async function mergeProjectSettings(root) {
-  const base = await readProjectSettings(root);
-  const { settings: withHooks } = mergeHooks(base, PROJECT_HOOK_FRAGMENTS);
-  const { settings: withDeny } = mergeDenyRules(withHooks, buildDenyRules());
-  const { settings: withAllow } = mergeAllowRules(withDeny, buildAllowRules());
-  const { settings: merged } = mergeAskRules(withAllow, buildAskRules());
-  return merged;
-}
-async function applyProjectSettingsMerge(root) {
-  const merged = await mergeProjectSettings(root);
-  await writeProjectSettings(root, merged);
-  return merged;
-}
-
-// src/claude/write-claude-files.ts
-import path12 from "path";
-import fs12 from "fs-extra";
-
-// src/catalog/load-catalog.ts
-import path6 from "path";
-async function loadCatalogContext(root) {
-  const envPath = process.env["HAUS_FIXTURE_CATALOG"];
-  if (envPath) {
-    const data2 = await readJson(envPath);
-    return {
-      items: data2?.items ?? [],
-      contentRoot: path6.dirname(envPath),
-      source: "fixture"
-    };
-  }
-  const cacheDir = getCacheDir();
-  const cacheManifestPath = path6.join(cacheDir, "manifest.json");
-  const cacheData = await readJson(cacheManifestPath);
-  if (cacheData?.items?.length) {
-    return { items: cacheData.items, contentRoot: cacheDir, source: "cache" };
-  }
-  const localManifest = path6.join(root, "library/catalog/manifest.json");
-  const localData = await readJson(localManifest);
-  if (localData?.items?.length) {
-    return {
-      items: localData.items,
-      contentRoot: path6.dirname(localManifest),
-      source: "local"
-    };
-  }
-  const packageManifest = path6.join(packageRoot(), "library/catalog/manifest.json");
-  const data = await readJson(packageManifest);
-  return {
-    items: data?.items ?? [],
-    contentRoot: path6.dirname(packageManifest),
-    source: "bundled"
-  };
-}
-async function loadCatalog(root) {
-  const ctx = await loadCatalogContext(root);
-  return ctx.items;
-}
-function catalogItemContentPath(contentRoot, item) {
-  return path6.join(contentRoot, item.path);
-}
-
-// src/update/hash-installed.ts
-import path7 from "path";
-import fg2 from "fast-glob";
-import fs4 from "fs-extra";
-
-// src/claude/managed-template.ts
-function normaliseLF(content2) {
-  return content2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-var SCHEMA_VERSION = 1;
-function parseHausManagedHeader(line2) {
-  const match = line2.match(/<!-- HAUS-MANAGED id=([\w.:-]+)/);
-  if (!match) return null;
-  const vMatch = line2.match(/\bv=(\d+)/);
-  const sourceMatch = line2.match(/\bsource=([^\s]+)/);
-  const hashMatch = line2.match(/hash=(sha256-[a-f0-9]+)/);
-  return {
-    id: match[1],
-    v: vMatch ? Number(vMatch[1]) : void 0,
-    source: sourceMatch?.[1],
-    hash: hashMatch?.[1]
-  };
-}
-
-// src/update/hash-installed.ts
-var EMPTY_LOCK_PATHS_TOKEN = "haus-lock:empty-paths";
-async function hashInstalledPaths(root, relPaths) {
-  if (relPaths.length === 0) {
-    return hashText(EMPTY_LOCK_PATHS_TOKEN);
+
+// src/security/ask-rules.ts
+function buildAskRules() {
+  const rules = [];
+  for (const command of ASK_COMMANDS) {
+    rules.push(`Bash(${command}:*)`);
   }
-  const normalized = [...new Set(relPaths.map((p) => p.replace(/\\/g, "/")))].sort();
-  const fileDigests = [];
-  for (const rel of normalized) {
-    const abs = path7.join(root, rel);
-    if (!await fs4.pathExists(abs)) continue;
-    const stat = await fs4.stat(abs);
-    if (stat.isFile()) {
-      const body = await fs4.readFile(abs, "utf8");
-      fileDigests.push({ rel, digest: hashText(normaliseLF(body)) });
-      continue;
-    }
-    if (!stat.isDirectory()) continue;
-    const inner = await fg2("**/*", { cwd: abs, onlyFiles: true, dot: true });
-    for (const sub of inner.sort()) {
-      const relFile = path7.join(rel, sub).replace(/\\/g, "/");
-      const absFile = path7.join(abs, sub);
-      const body = await fs4.readFile(absFile, "utf8");
-      fileDigests.push({ rel: relFile, digest: hashText(normaliseLF(body)) });
+  for (const { pattern, tools } of ASK_PATHS) {
+    for (const tool of tools) {
+      rules.push(`${tool}(${pattern})`);
     }
   }
-  if (fileDigests.length === 0) {
-    return hashText(`${EMPTY_LOCK_PATHS_TOKEN}|${normalized.join("|")}`);
-  }
-  fileDigests.sort((a, b) => a.rel.localeCompare(b.rel));
-  return hashText(fileDigests.map((f) => `${f.rel}=${f.digest}`).join("|"));
+  return [...new Set(rules)];
 }
 
-// src/claude/managed-write.ts
-import fs5 from "fs-extra";
-
-// src/utils/diff.ts
-import { createTwoFilesPatch } from "diff";
-function hasTextChanged(before, after) {
-  return before !== after;
-}
-function createUnifiedDiff(filePath, before, after) {
-  return createTwoFilesPatch(filePath, filePath, before, after, "before", "after", {
-    context: 3
-  });
-}
-function summarizeDiff(diffText) {
-  const lines = diffText.split("\n");
-  let additions = 0;
-  let deletions = 0;
-  for (const line2 of lines) {
-    if (line2.startsWith("+++ ") || line2.startsWith("--- ")) continue;
-    if (line2.startsWith("+")) additions += 1;
-    if (line2.startsWith("-")) deletions += 1;
+// src/security/deny-rules.ts
+var FILE_TOOLS = ["Read", "Edit", "Write"];
+function buildDenyRules() {
+  const rules = [];
+  for (const command of DENY_COMMANDS) {
+    rules.push(`Bash(${command}:*)`);
   }
-  return { additions, deletions };
-}
-
-// 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`);
+  for (const path36 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path36) ? `${path36}/**` : path36;
+    for (const tool of FILE_TOOLS) {
+      rules.push(`${tool}(${pattern})`);
     }
-    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})`);
+  return [...new Set(rules)];
+}
+
+// src/claude/merge-project-settings.ts
+var PROJECT_HOOK_FRAGMENTS = [
+  {
+    id: "haus.guard-file",
+    gate: "keep",
+    event: "PreToolUse",
+    matcher: "Read|Edit|Write",
+    command: "haus guard file-access --from-hook"
+  },
+  {
+    id: "haus.guard-bash",
+    gate: "keep",
+    event: "PreToolUse",
+    matcher: "Bash",
+    command: "haus guard bash --from-hook"
   }
-  await writeText(filePath, nextText);
+];
+async function readProjectSettings(root) {
+  const filePath = claudePath(root, "settings.json");
+  const result = await readJsonDetailed(filePath);
+  if (result.status === "ok") return result.value;
+  if (result.status === "missing") return {};
+  const backupPath = await backupMalformedJsonFile(filePath);
+  throw new MalformedJsonFileError(filePath, backupPath);
 }
-async function writeManagedJson(root, filePath, value, dryRun) {
-  const nextText = `${JSON.stringify(value, null, 2)}
-`;
-  await writeManagedText(root, filePath, nextText, dryRun);
+async function writeProjectSettings(root, settings) {
+  await writeJson(claudePath(root, "settings.json"), settings);
+}
+async function mergeProjectSettings(root) {
+  const base = await readProjectSettings(root);
+  const { settings: withHooks } = mergeHooks(base, PROJECT_HOOK_FRAGMENTS);
+  const { settings: withDeny } = mergeDenyRules(withHooks, buildDenyRules());
+  const { settings: withAllow } = mergeAllowRules(withDeny, buildAllowRules());
+  const { settings: merged } = mergeAskRules(withAllow, buildAskRules());
+  return merged;
+}
+async function applyProjectSettingsMerge(root) {
+  const merged = await mergeProjectSettings(root);
+  await writeProjectSettings(root, merged);
+  return merged;
 }
 
 // src/claude/superpowers-install.ts
@@ -1613,25 +1744,50 @@ function buildImportBlock() {
 ${IMPORT_CONTENT}
 ${BLOCK_END}`;
 }
+function findLineMarker(content2, marker, from = 0) {
+  let idx = content2.indexOf(marker, from);
+  while (idx !== -1) {
+    const lineStart = idx === 0 || content2[idx - 1] === "\n";
+    const after = idx + marker.length;
+    const lineEnd = after === content2.length || content2[after] === "\n" || content2[after] === "\r";
+    if (lineStart && lineEnd) return { start: idx, end: after };
+    idx = content2.indexOf(marker, idx + marker.length);
+  }
+  return null;
+}
+function findImportBlockRange(content2) {
+  const begin = findLineMarker(content2, BLOCK_BEGIN);
+  if (!begin) return null;
+  const end = findLineMarker(content2, BLOCK_END, begin.end);
+  if (!end) return null;
+  return { beginStart: begin.start, beginEnd: begin.end, endStart: end.start, endEnd: end.end };
+}
 function stripHausBlock(existing) {
-  const beginIdx = existing.indexOf(BLOCK_BEGIN);
-  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 range = findImportBlockRange(existing);
+  if (!range) return existing;
+  const before = existing.slice(0, range.beginStart);
+  const after = existing.slice(range.endEnd);
   const merged = `${before}${after}`.replace(/\n{3,}/g, "\n\n").trimEnd();
   return merged.length > 0 ? `${merged}
 ` : "";
 }
 function injectHausBlock(existing, block) {
-  const beginIdx = existing.indexOf(BLOCK_BEGIN);
-  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);
+  const range = findImportBlockRange(existing);
+  if (range) {
+    const before = existing.slice(0, range.beginStart);
+    const after = existing.slice(range.endEnd);
     return `${before}${block}${after}`;
   }
+  const loneBegin = findLineMarker(existing, BLOCK_BEGIN);
+  if (loneBegin) {
+    const before = existing.slice(0, loneBegin.start).trimEnd();
+    if (before.length === 0) return `${block}
+`;
+    return `${before}
+
+${block}
+`;
+  }
   const trimmed = existing.trimEnd();
   if (trimmed.length === 0) {
     return `${block}
@@ -1816,6 +1972,12 @@ ${templateContent}`;
       return null;
     }
     const existingContent = existing.slice(firstLine.length + 1);
+    if (!parsed.hash && !force) {
+      warn(
+        `${printable}: managed header missing hash \u2014 cannot verify tamper status, skipping. Use --force to overwrite.`
+      );
+      return null;
+    }
     if (parsed.hash && hashText(normaliseLF(existingContent)) !== parsed.hash && !force) {
       warn(`${printable}: content modified by user \u2014 skipping. Use --force to overwrite.`);
       return null;
@@ -2174,18 +2336,6 @@ async function runApply(options) {
     files.forEach((f) => log(`- ${displayPath(root, f)}`));
   }
 }
-async function isHausProject(root) {
-  if (await fs13.pathExists(hausPath(root, "recommendation.json"))) return true;
-  if (await fs13.pathExists(claudePath(root, "settings.json"))) {
-    const settings = await readProjectSettings(root);
-    if (settings._haus != null) return true;
-  }
-  return false;
-}
-async function refreshProjectApply(root) {
-  if (!await isHausProject(root)) return [];
-  return writeClaudeFiles(root, false, void 0, { refillConfig: false });
-}
 
 // src/commands/catalog-audit.ts
 function auditForbiddenTags(items) {
@@ -2287,7 +2437,7 @@ async function runClone(url, opts = {}) {
 
 // src/commands/doctor.ts
 import path19 from "path";
-import fs15 from "fs-extra";
+import fs14 from "fs-extra";
 
 // src/scanner/scan-project.ts
 import path18 from "path";
@@ -2318,7 +2468,7 @@ function compareVersions(a, b) {
 
 // src/scanner/detect-package-manager.ts
 import path15 from "path";
-import fs14 from "fs-extra";
+import fs13 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -2336,9 +2486,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs14.existsSync(path15.join(root, "yarn.lock"))) return "yarn";
-  if (fs14.existsSync(path15.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs14.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";
 }
 
@@ -2851,7 +3001,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 fs15.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`,
@@ -2862,7 +3012,7 @@ async function runDoctor(options) {
     }
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs15.pathExists(workflowPath);
+  const workflowExists = await fs14.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -2893,7 +3043,7 @@ async function runDoctor(options) {
           "templates",
           "agentic-workflow-standard.md"
         );
-        const templatePath = await fs15.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));
@@ -2913,7 +3063,7 @@ async function runDoctor(options) {
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs15.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs14.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -2921,7 +3071,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs15.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(
@@ -2961,9 +3111,6 @@ async function runDoctor(options) {
       `A newer haus (${npmStatus.latest}) is available`,
       `npm install -g ${NPM_PACKAGE_NAME}`
     );
-    if (!process.env["HAUS_FIXTURE_CATALOG"]) {
-      process.exitCode = 1;
-    }
   } else if (npmStatus.latest !== null) {
     ok(`- CLI: ${currentVersion} (up to date)`);
   } else {
@@ -3110,15 +3257,23 @@ async function runExplainRecommendation(options) {
 import { readFileSync as readFileSync2 } from "fs";
 
 // src/security/guard-bash.ts
+function matchesDenyToken(command, denyPhrase) {
+  if (denyPhrase === "sudo") {
+    return /(?:^|[|;&]\s*)sudo\b/i.test(command);
+  }
+  const normalizedCommand = command.toLowerCase().replace(/\s+/g, " ").trim();
+  return normalizedCommand.includes(denyPhrase.toLowerCase());
+}
 function guardBash(command) {
-  const matched = DENY_COMMANDS.find((token) => command.includes(token));
+  const matched = DENY_COMMANDS.find((denyPhrase) => matchesDenyToken(command, denyPhrase));
   if (matched) return `I didn't run that \u2014 it can permanently change or delete things: ${command}`;
   return void 0;
 }
 
 // src/security/guard-file-access.ts
 function guardFileAccess(candidate) {
-  const matched = DENY_PATHS.find((token) => candidate.includes(token.replace(/\*/g, "")));
+  const normalized = normalizePathForMatch(candidate);
+  const matched = DENY_PATH_REGEXES.find((re) => re.test(normalized));
   if (matched)
     return `I didn't open ${candidate} \u2014 it looks like it holds secrets or sensitive data`;
   return void 0;
@@ -3170,7 +3325,7 @@ async function runGuard(kind, _options) {
 
 // src/commands/init.ts
 import path20 from "path";
-import fs16 from "fs-extra";
+import fs15 from "fs-extra";
 
 // src/utils/prompts.ts
 import { stdin as input, stdout as output } from "process";
@@ -3518,7 +3673,7 @@ async function runSetupProject(options) {
 async function runInit(options) {
   const root = process.cwd();
   const hausDir = path20.join(root, ".haus-workflow");
-  const alreadyInit = await fs16.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.");
@@ -3531,7 +3686,7 @@ async function runInit(options) {
 // src/install/apply.ts
 import crypto2 from "crypto";
 import path21 from "path";
-import fs17 from "fs-extra";
+import fs16 from "fs-extra";
 
 // src/install/header.ts
 var MD_PREFIX = "<!-- HAUS-MANAGED";
@@ -3539,11 +3694,9 @@ var MD_SUFFIX = " -->";
 var FM_FENCE = "---";
 var FM_KEY = "haus_managed";
 function parseAttrs(raw) {
-  const idMatch = /\bid=(\S+)/.exec(raw);
-  const vMatch = /\bv=(\S+)/.exec(raw);
-  const srcMatch = /\bsource=(\S+)/.exec(raw);
-  if (!idMatch || !vMatch || !srcMatch) return void 0;
-  return { stableId: idMatch[1], schemaVersion: vMatch[1], source: srcMatch[1] };
+  const attrs = parseHausManagedAttrs(raw) ?? parseHausManagedAttrs(`<!-- HAUS-MANAGED ${raw.trim()} -->`);
+  if (!attrs?.id || !attrs.v || !attrs.source) return void 0;
+  return { stableId: attrs.id, schemaVersion: attrs.v, source: attrs.source };
 }
 function isFence(line2) {
   return (line2 ?? "").replace(/\r$/, "") === FM_FENCE;
@@ -3620,7 +3773,7 @@ function hashContent(content2) {
 function sourceVersion() {
   try {
     const pkgPath = path21.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs17.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";
@@ -3632,10 +3785,10 @@ function globalSrcDir() {
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
   const skillsDir = path21.join(srcDir, "skills");
-  if (fs17.pathExistsSync(skillsDir)) {
-    for (const skillName of fs17.readdirSync(skillsDir)) {
+  if (fs16.pathExistsSync(skillsDir)) {
+    for (const skillName of fs16.readdirSync(skillsDir)) {
       const skillFile = path21.join(skillsDir, skillName, "SKILL.md");
-      if (fs17.pathExistsSync(skillFile)) {
+      if (fs16.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
           srcRelPath: path21.join("library", "global", "skills", skillName, "SKILL.md"),
@@ -3645,8 +3798,8 @@ function collectSourceFiles(srcDir, claudeDir) {
     }
   }
   const commandsDir = path21.join(srcDir, "commands");
-  if (fs17.pathExistsSync(commandsDir)) {
-    for (const fileName of fs17.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({
@@ -3696,7 +3849,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs17.pathExistsSync(entry.destPath);
+    const destExists = fs16.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -3744,13 +3897,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 (!fs17.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 fs17.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`);
@@ -3761,8 +3914,7 @@ async function applyInstall(options = {}) {
   if (!dryRun && !check) {
     await writeSettings(mergedSettings);
     const manifest = buildManifest(source, manifestFiles, [
-      ...existingManifest?.hooks ?? [],
-      ...addedIds
+      .../* @__PURE__ */ new Set([...existingManifest?.hooks ?? [], ...addedIds])
     ]);
     await writeManifest(manifest);
   }
@@ -3794,6 +3946,59 @@ function printApplyResult(result, dryRun) {
   }
 }
 
+// src/install/companion-tools.ts
+import { execaSync } from "execa";
+var COMPANION_TOOLS = [
+  {
+    bin: "caveman",
+    label: "Caveman",
+    blurb: "Ultra-compressed Claude Code responses \u2014 cuts output tokens ~75%.",
+    installCmds: [
+      "curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash"
+    ],
+    url: "https://github.com/JuliusBrussee/caveman"
+  },
+  {
+    bin: "rtk",
+    label: "RTK (Rust Token Killer)",
+    blurb: "Token-optimized CLI proxy \u2014 60-90% savings on dev operations.",
+    installCmds: [
+      "brew install rtk",
+      "cargo install --git https://github.com/rtk-ai/rtk   # if Homebrew is unavailable"
+    ],
+    url: "https://github.com/rtk-ai/rtk",
+    note: 'Another crate named "rtk" (Rust Type Kit) exists on crates.io \u2014 use the commands above, not a bare `cargo install rtk`.'
+  }
+];
+function buildCompanionSuggestions(tools, isInstalled) {
+  const missing = tools.filter((t) => !isInstalled(t.bin));
+  if (missing.length === 0) return [];
+  const lines = ["", "Optional token-saving tools you can add:"];
+  for (const tool of missing) {
+    lines.push("", `  ${tool.label} \u2014 ${tool.blurb}`);
+    for (const cmd of tool.installCmds) {
+      lines.push(`    ${cmd}`);
+    }
+    if (tool.note) lines.push(`    note: ${tool.note}`);
+    lines.push(`    ${tool.url}`);
+  }
+  return lines;
+}
+function commandExists(bin) {
+  try {
+    const r = execaSync("sh", ["-c", 'command -v -- "$1"', "probe", bin], { reject: false });
+    return r.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+function printCompanionToolSuggestions(deps = {}) {
+  const isInstalled = deps.isInstalled ?? commandExists;
+  const emit2 = deps.log ?? log;
+  const lines = buildCompanionSuggestions(COMPANION_TOOLS, isInstalled);
+  for (const line2 of lines) emit2(line2);
+}
+
 // src/commands/install.ts
 async function runInstall(options) {
   try {
@@ -3806,6 +4011,7 @@ async function runInstall(options) {
     if (options.check && result.drift) {
       process.exitCode = 1;
     } else if (!options.check && !options.dryRun) {
+      printCompanionToolSuggestions();
       const total = result.created.length + result.updated.length;
       if (options.postinstall) {
         log("haus configured Claude Code for you:");
@@ -3871,7 +4077,7 @@ async function runScan(options) {
 
 // src/commands/undo.ts
 import path22 from "path";
-import fs18 from "fs-extra";
+import fs17 from "fs-extra";
 
 // src/claude/managed-paths.ts
 var PROJECT_MANAGED_CLAUDE_REL = ["rules/haus.md", "commands/haus-doctor.md"];
@@ -3893,25 +4099,25 @@ async function collectManagedPaths(root) {
   }
   const existing = [];
   for (const abs of paths) {
-    if (await fs18.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 fs18.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 fs18.pathExists(filePath)) return false;
-  const text = await fs18.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 fs18.pathExists(settingsPath)) return false;
+  if (!await fs17.pathExists(settingsPath)) return false;
   let settings = await readProjectSettings(root);
   settings = stripHausHooks(stripHausAsk(stripHausAllow(stripHausDeny(settings))));
   const hasContent = Object.keys(settings).length > 0;
@@ -3920,29 +4126,42 @@ async function stripProjectSettings(root) {
     log(`Stripped haus rules from ${path22.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs18.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 fs18.pathExists(filePath)) return false;
-  const prev = await fs18.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 fs18.remove(filePath);
+    await fs17.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs18.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 fs18.pathExists(dir)) return;
-  const entries = await fs18.readdir(dir);
-  if (entries.length === 0) await fs18.remove(dir);
+  if (!await fs17.pathExists(dir)) return;
+  const entries = await fs17.readdir(dir);
+  if (entries.length === 0) await fs17.remove(dir);
+}
+async function backupManagedFilesBeforeUndo(root, managedAbsPaths) {
+  if (managedAbsPaths.length === 0) return;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupRoot = hausPath(root, "backups", `undo-${stamp}`);
+  for (const abs of managedAbsPaths) {
+    if (!await fs17.pathExists(abs)) continue;
+    const rel = path22.relative(root, abs);
+    const backupPath = path22.join(backupRoot, rel);
+    await fs17.ensureDir(path22.dirname(backupPath));
+    await fs17.copy(abs, backupPath);
+  }
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path22.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
   const root = process.cwd();
@@ -3968,9 +4187,10 @@ User-owned .claude/ files will be preserved.`
       return;
     }
   }
+  await backupManagedFilesBeforeUndo(root, managed);
   for (const abs of managed) {
-    if (!await fs18.pathExists(abs)) continue;
-    await fs18.remove(abs);
+    if (!await fs17.pathExists(abs)) continue;
+    await fs17.remove(abs);
     log(`Removed ${path22.relative(root, abs)}`);
   }
   if (stripSettings) await stripProjectSettings(root);
@@ -3983,7 +4203,7 @@ User-owned .claude/ files will be preserved.`
 // src/install/uninstall.ts
 import crypto3 from "crypto";
 import path23 from "path";
-import fs19 from "fs-extra";
+import fs18 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
   const manifest = await readManifest();
@@ -3993,7 +4213,7 @@ async function runUninstall(options = {}) {
     return result;
   }
   for (const entry of manifest.files) {
-    const exists = fs19.pathExistsSync(entry.destPath);
+    const exists = fs18.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -4011,7 +4231,7 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs19.remove(entry.destPath);
+    await fs18.remove(entry.destPath);
     await pruneEmptyDir(path23.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
@@ -4021,12 +4241,12 @@ async function runUninstall(options = {}) {
   result.hooksStripped = true;
   const hausDir = path23.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs19.pathExistsSync(manifestPath2)) {
-    await fs19.remove(manifestPath2);
+  if (fs18.pathExistsSync(manifestPath2)) {
+    await fs18.remove(manifestPath2);
   }
-  if (fs19.pathExistsSync(hausDir)) {
-    const remaining = await fs19.readdir(hausDir);
-    if (remaining.length === 0) await fs19.remove(hausDir);
+  if (fs18.pathExistsSync(hausDir)) {
+    const remaining = await fs18.readdir(hausDir);
+    if (remaining.length === 0) await fs18.remove(hausDir);
   }
   return result;
 }
@@ -4059,6 +4279,19 @@ async function runUninstallCommand(options) {
 // src/commands/update.ts
 import path25 from "path";
 
+// src/claude/refresh-project.ts
+import fs19 from "fs-extra";
+async function isHausProject(root) {
+  if (await fs19.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;
+}
+async function refreshProjectApply(root) {
+  if (!await isHausProject(root)) return [];
+  return writeClaudeFiles(root, false, void 0, { refillConfig: false });
+}
+
 // src/update/diff-generated-files.ts
 function diffGeneratedFiles() {
   return "Generated files may change in .claude/* and .haus-workflow/haus.lock.json. Review git diff before apply.";
@@ -4256,8 +4489,18 @@ async function detectGlobalInstallDrift() {
 }
 
 // src/commands/validate-catalog.ts
+import path27 from "path";
+
+// src/catalog/validate-core.ts
 import fs20 from "fs";
 import path26 from "path";
+var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
+var MANIFEST_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+function isSafeCatalogPath2(itemPath) {
+  if (!itemPath || path26.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
+  const normalized = path26.normalize(itemPath);
+  return !normalized.startsWith("..") && !normalized.includes("/..");
+}
 function auditForbiddenStacks(items) {
   const failures = [];
   for (const item of items) {
@@ -4269,10 +4512,15 @@ function auditForbiddenStacks(items) {
   }
   return failures;
 }
-function auditManifestStructure(items) {
+function auditManifestStructure(manifestVersion, items) {
   const failures = [];
   const seenIds = /* @__PURE__ */ new Map();
   const seenPaths = /* @__PURE__ */ new Map();
+  if (typeof manifestVersion !== "string" || !MANIFEST_SEMVER_RE.test(manifestVersion)) {
+    failures.push(
+      'manifest.json: top-level "version" is not valid semver (expected X.Y.Z or X.Y.Z-pre)'
+    );
+  }
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
     if (!item.id) {
@@ -4283,11 +4531,10 @@ function auditManifestStructure(items) {
       failures.push(`${item.id}: missing type`);
       continue;
     }
-    if (!item.source) {
-      failures.push(`${item.id}: missing source`);
-    }
-    if (!item.title) {
-      failures.push(`${item.id}: missing title`);
+    if (!item.source) failures.push(`${item.id}: missing source`);
+    if (!item.title) failures.push(`${item.id}: missing title`);
+    if (item.version && !ITEM_SEMVER_RE.test(item.version)) {
+      failures.push(`${item.id}: version "${item.version}" is not valid semver (expected X.Y.Z)`);
     }
     const prev = seenIds.get(item.id);
     if (prev !== void 0) {
@@ -4298,14 +4545,13 @@ function auditManifestStructure(items) {
     if (item.type === "skill" || item.type === "agent" || item.type === "template" || item.type === "command") {
       if (!item.path) {
         failures.push(`${item.id}: missing path`);
+      } else if (!isSafeCatalogPath2(item.path)) {
+        failures.push(`${item.id}: path "${item.path}" is not a safe relative path`);
       } else {
         const norm = item.path.replace(/\\/g, "/");
         const existing = seenPaths.get(norm);
-        if (existing) {
-          failures.push(`${item.id}: path "${norm}" already used by ${existing}`);
-        } else {
-          seenPaths.set(norm, item.id);
-        }
+        if (existing) failures.push(`${item.id}: path "${norm}" already used by ${existing}`);
+        else seenPaths.set(norm, item.id);
       }
       const isHaus = item.source === "haus";
       const isCuratedApproved = item.source === "curated" && item.reviewStatus === "approved";
@@ -4313,8 +4559,13 @@ function auditManifestStructure(items) {
         failures.push(`${item.id}: source must be "haus" or curated with reviewStatus "approved"`);
       }
       for (const ref of item.references ?? []) {
-        if (HTTP_URL_PATTERN.test(ref)) {
-          failures.push(`${item.id}: reference uses insecure http:// URL: ${ref}`);
+        if (/^https?:\/\//i.test(ref)) {
+          if (!ref.startsWith("https://")) {
+            failures.push(`${item.id}: reference must be https:// URL: ${ref}`);
+          }
+          if (HTTP_URL_PATTERN.test(ref)) {
+            failures.push(`${item.id}: reference uses insecure http:// URL: ${ref}`);
+          }
         }
       }
     }
@@ -4324,16 +4575,33 @@ function auditManifestStructure(items) {
 function checkRequiredFrontmatter(text, label) {
   const failures = [];
   for (const key of REQUIRED_SKILL_FRONTMATTER) {
-    if (!extractFrontmatterValue(text, key)) {
+    if (!extractFrontmatterValue(text, key))
       failures.push(`${label}: missing non-empty frontmatter '${key}:'`);
+  }
+  return failures;
+}
+function auditTemplateContent(manifestDir, absPath, itemId) {
+  const rel = path26.relative(manifestDir, absPath);
+  const text = fs20.readFileSync(absPath, "utf8");
+  const failures = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line2 = lines[i] ?? "";
+    if (PLACEHOLDER_PATTERN.test(line2))
+      failures.push(`${rel}:${i + 1}: TODO or placeholder in shipped content`);
+    if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2)))
+      failures.push(`${rel}:${i + 1}: risky install pattern`);
+    if (ANY_NPX_PATTERN.test(line2) && !ALLOWED_NPX_PATTERN.test(line2)) {
+      failures.push(`${rel}:${i + 1}: disallowed npx (only npx tsx allowed)`);
     }
   }
+  failures.push(...auditForbiddenTagsInText(text, `${itemId}: ${rel}`));
   return failures;
 }
 function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
-    if (!item.path) continue;
+    if (!item.path || !isSafeCatalogPath2(item.path)) continue;
     const absPath = path26.join(manifestDir, item.path);
     if (item.type === "skill") {
       const skillMd = path26.join(absPath, "SKILL.md");
@@ -4374,36 +4642,22 @@ function auditShippedFiles(manifestDir, items) {
   }
   return failures;
 }
-function auditTemplateContent(manifestDir, absPath, itemId) {
-  const rel = path26.relative(manifestDir, absPath);
-  const text = fs20.readFileSync(absPath, "utf8");
-  const failures = [];
-  const lines = text.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line2 = lines[i] ?? "";
-    if (PLACEHOLDER_PATTERN.test(line2)) {
-      failures.push(`${rel}:${i + 1}: TODO or placeholder in shipped content`);
-    }
-    if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2))) {
-      failures.push(`${rel}:${i + 1}: risky install pattern`);
-    }
-    if (ANY_NPX_PATTERN.test(line2) && !ALLOWED_NPX_PATTERN.test(line2)) {
-      failures.push(`${rel}:${i + 1}: disallowed npx (only npx tsx allowed)`);
-    }
-  }
-  failures.push(...auditForbiddenTagsInText(text, `${itemId}: ${rel}`));
-  return failures;
-}
 var DIR_ITEM_TYPE = {
   skills: "skill",
   agents: "agent",
   templates: "template",
   commands: "command"
 };
+function walkMd(dir, fn) {
+  for (const entry of fs20.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);
+  }
+}
 function auditMarkdownContent(manifestDir) {
   const failures = [];
-  const dirs = ["skills", "agents", "templates", "commands"];
-  for (const dir of dirs) {
+  for (const dir of ["skills", "agents", "templates", "commands"]) {
     const abs = path26.join(manifestDir, dir);
     if (!fs20.existsSync(abs)) continue;
     const checkNonTsxNpx = !NPX_TSX_ONLY_EXEMPT_TYPES.includes(DIR_ITEM_TYPE[dir] ?? "");
@@ -4413,65 +4667,55 @@ function auditMarkdownContent(manifestDir) {
       const lines = text.split(/\r?\n/);
       for (let i = 0; i < lines.length; i++) {
         const line2 = lines[i] ?? "";
-        if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2))) {
+        if (RISKY_INSTALL_PATTERNS.some((re) => re.test(line2)))
           failures.push(`${rel}:${i + 1}: risky install pattern`);
-        }
         if (checkNonTsxNpx && ANY_NPX_PATTERN.test(line2) && !ALLOWED_NPX_PATTERN.test(line2)) {
           failures.push(`${rel}:${i + 1}: disallowed npx (only npx tsx allowed)`);
         }
       }
-      if (!rel.includes("/references/")) {
-        failures.push(...auditForbiddenTagsInText(text, rel));
-      }
+      if (!rel.includes("/references/")) failures.push(...auditForbiddenTagsInText(text, rel));
     });
   }
   return failures;
 }
-function walkMd(dir, fn) {
-  for (const entry of fs20.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);
-  }
+function validateCatalogData(manifestDir, manifestVersion, items) {
+  const failures = [
+    ...auditManifestStructure(manifestVersion, items),
+    ...auditForbiddenStacks(items),
+    ...auditShippedFiles(manifestDir, items),
+    ...auditMarkdownContent(manifestDir),
+    ...auditDisallowedTags(items)
+  ];
+  return { ok: failures.length === 0, failures, items };
 }
+
+// src/commands/validate-catalog.ts
 async function runValidateCatalog(manifestPath2) {
   if (!manifestPath2) {
     error("Usage: haus validate-catalog <path/to/manifest.json>");
     process.exitCode = 1;
     return;
   }
-  const abs = path26.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path26.dirname(abs);
+  const abs = path27.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path27.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
     process.exitCode = 1;
     return;
   }
-  const items = data.items;
-  const structureFailures = auditManifestStructure(items);
-  const stackFailures = auditForbiddenStacks(items);
-  const fileFailures = auditShippedFiles(manifestDir, items);
-  const contentFailures = auditMarkdownContent(manifestDir);
-  const tagFailures = auditDisallowedTags(items);
-  const allFailures = [
-    ...structureFailures,
-    ...stackFailures,
-    ...fileFailures,
-    ...contentFailures,
-    ...tagFailures
-  ];
-  if (allFailures.length) {
-    allFailures.forEach((f) => error(f));
+  const result = validateCatalogData(manifestDir, data.version, data.items);
+  if (!result.ok) {
+    result.failures.forEach((f) => error(f));
     process.exitCode = 1;
     return;
   }
-  log(`Catalog valid. ${items.length} items checked.`);
+  log(`Catalog valid. ${result.items.length} items checked.`);
 }
 
 // src/commands/workspace.ts
 import { existsSync as existsSync5, statSync as statSync2 } from "fs";
-import path33 from "path";
+import path34 from "path";
 
 // src/commands/workspace/aggregate.ts
 async function writeWorkspaceArtifacts(workspaceRoot, repos, relationships = []) {
@@ -4525,7 +4769,7 @@ ${summaries.map(
 }
 
 // src/commands/workspace/config.ts
-import path27 from "path";
+import path28 from "path";
 import YAML from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
@@ -4548,11 +4792,11 @@ function parseWorkspaceConfig(text) {
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
-  return parseWorkspaceConfig(await readText(path27.join(workspaceRoot, WORKSPACE_FILE)));
+  return parseWorkspaceConfig(await readText(path28.join(workspaceRoot, WORKSPACE_FILE)));
 }
 
 // src/commands/workspace/discover.ts
-import path28 from "path";
+import path29 from "path";
 import fg4 from "fast-glob";
 import YAML2 from "yaml";
 var DEFAULT_MAX_DEPTH = 3;
@@ -4580,8 +4824,8 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const gitDirs = /* @__PURE__ */ new Set();
   const manifestDirs = /* @__PURE__ */ new Set();
   for (const match of matches) {
-    const base = path28.posix.basename(match);
-    const dir = path28.posix.dirname(match);
+    const base = path29.posix.basename(match);
+    const dir = path29.posix.dirname(match);
     const owner = dir === "." ? "." : dir;
     if (base === ".git") gitDirs.add(owner);
     else manifestDirs.add(owner);
@@ -4597,9 +4841,9 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   }
   repoRoots.sort((a, b) => a.localeCompare(b));
   return mapWithConcurrency(repoRoots, async (relDir) => {
-    const absDir = path28.resolve(workspaceRoot, relDir);
-    const pkg = await readJson(path28.join(absDir, "package.json"));
-    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path28.basename(relDir === "." ? workspaceRoot : absDir);
+    const absDir = path29.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path29.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path29.basename(relDir === "." ? workspaceRoot : absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir);
@@ -4642,7 +4886,7 @@ function renderWorkspaceYaml(config) {
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path28.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path29.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -4676,18 +4920,18 @@ async function runDiscover(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync3 } from "fs";
-import path30 from "path";
+import path31 from "path";
 
 // src/commands/workspace/manifest.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path29 from "path";
+import path30 from "path";
 var MANIFEST_FILE = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(path29.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path30.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -4753,7 +4997,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
   }
   const manifestByName = new Map(manifest.repos.map((r) => [r.name, r]));
   for (const repo of config.repos) {
-    const repoRoot = path30.resolve(workspaceRoot, repo.path);
+    const repoRoot = path31.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -4827,10 +5071,10 @@ function emit(args) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync4, statSync } from "fs";
-import path32 from "path";
+import path33 from "path";
 
 // src/claude/write-workspace-claude-md.ts
-import path31 from "path";
+import path32 from "path";
 import fs21 from "fs-extra";
 function buildWorkspaceImportBlock(client, members) {
   const memberLines = members.map((m) => `- ${m.name} (${m.path})`);
@@ -4849,7 +5093,7 @@ ${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") : path31.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path32.join(workspaceRoot, "CLAUDE.md");
   const prev = await fs21.pathExists(filePath) ? await fs21.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block);
@@ -4875,20 +5119,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 
 // src/commands/workspace/setup.ts
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path32.resolve(start);
+  let dir = path33.resolve(start);
   for (; ; ) {
-    if (existsSync4(path32.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path32.dirname(dir);
-    if (parent === dir) return path32.resolve(start);
+    if (existsSync4(path33.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path33.dirname(dir);
+    if (parent === dir) return path33.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path32.resolve(workspaceRoot, repoPath) === path32.resolve(workspaceRoot);
+  return path33.resolve(workspaceRoot, repoPath) === path33.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path32.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path33.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -4905,7 +5149,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path32.resolve(workspaceRoot, repo.path);
+    const repoRoot = path33.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -4973,7 +5217,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(path32.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path33.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -5053,7 +5297,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path33.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path34.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -5074,7 +5318,7 @@ async function scanWorkspace(workspaceRoot, opts) {
   }
   const inputs = [];
   for (const repo of config.repos) {
-    const repoRoot = path33.resolve(workspaceRoot, repo.path);
+    const repoRoot = path34.resolve(workspaceRoot, repo.path);
     if (!existsSync5(repoRoot) || !statSync2(repoRoot).isDirectory()) {
       throw new Error(`Repo path is not a directory: ${repo.path}`);
     }
@@ -5124,7 +5368,7 @@ async function runWorkspace(action, options = {}) {
 // src/cli.ts
 function cliVersion() {
   try {
-    const pkgPath = path34.join(packageRoot(), "package.json");
+    const pkgPath = path35.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -5134,7 +5378,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path34.join(packageRoot(), "package.json");
+    const pkgPath = path35.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {