@haus-tech/haus-workflow 4.0.0 → 4.1.0

package/dist/cli.js

@@ -14,9 +14,122 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/catalog/offline.ts
+function setOfflineFlag(value) {
+  flagged = value;
+}
+function isOffline() {
+  return flagged || process.env["HAUS_OFFLINE"] === "1";
+}
+var flagged;
+var init_offline = __esm({
+  "src/catalog/offline.ts"() {
+    "use strict";
+    flagged = false;
+  }
+});
+
+// src/utils/paths.ts
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function hausPath(root, ...parts) {
+  return path.join(root, HAUS_DIR, ...parts);
+}
+function claudePath(root, ...parts) {
+  return path.join(root, ".claude", ...parts);
+}
+function claudeConfigDir() {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  if (override && override.trim().length > 0) return override;
+  return path.join(os.homedir(), ".claude");
+}
+function defaultClaudeConfigDir() {
+  return path.join(os.homedir(), ".claude");
+}
+function claudeConfigDirIsRelocated() {
+  return path.resolve(claudeConfigDir()) !== path.resolve(defaultClaudeConfigDir());
+}
+function claudeConfigDirLabel() {
+  return claudeConfigDirIsRelocated() ? claudeConfigDir().replace(/\\/g, "/") : "~/.claude";
+}
+function displayPath(root, targetPath) {
+  const rel = path.relative(root, targetPath).replace(/\\/g, "/");
+  if (rel && !rel.startsWith("../") && rel !== "..") {
+    return rel.startsWith("./") ? rel : `./${rel}`;
+  }
+  if (claudeConfigDirIsRelocated()) {
+    const configDir = claudeConfigDir();
+    const configRel = path.relative(configDir, targetPath).replace(/\\/g, "/");
+    if (configRel === "") return "$CLAUDE_CONFIG_DIR";
+    if (!configRel.startsWith("../") && configRel !== "..") {
+      return `$CLAUDE_CONFIG_DIR/${configRel}`;
+    }
+  }
+  const home = os.homedir();
+  const normalized = targetPath.replace(/\\/g, "/");
+  if (home && home.trim().length > 0) {
+    const homeRel = path.relative(home, targetPath).replace(/\\/g, "/");
+    if (homeRel && !homeRel.startsWith("../") && homeRel !== "..") {
+      return `~/${homeRel}`;
+    }
+  }
+  return normalized;
+}
+function packageRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = path.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 = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const file = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(file), "../..");
+}
+var HAUS_DIR;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    HAUS_DIR = ".haus-workflow";
+  }
+});
+
+// src/catalog/path-safety.ts
+import path2 from "node:path";
+function isSafeCatalogPath(itemPath) {
+  if (!itemPath || path2.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
+  const normalized = path2.normalize(itemPath);
+  return !normalized.startsWith("..") && !normalized.includes("/..");
+}
+function isSafeRelativeFilePath(rel) {
+  if (!rel || rel.startsWith("/") || rel.includes("\\") || rel.includes("//")) return false;
+  if (path2.isAbsolute(rel)) return false;
+  const normalized = path2.posix.normalize(rel.replace(/\\/g, "/"));
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+}
+function safeJoin(base, itemPath) {
+  if (!isSafeCatalogPath(itemPath)) return null;
+  const resolved = path2.resolve(base, itemPath);
+  return resolved.startsWith(base + path2.sep) || resolved === base ? resolved : null;
+}
+var init_path_safety = __esm({
+  "src/catalog/path-safety.ts"() {
+    "use strict";
+  }
+});
+
 // src/utils/fs.ts
 import crypto from "node:crypto";
-import path from "node:path";
+import path5 from "node:path";
 import fg from "fast-glob";
 import fs from "fs-extra";
 async function readJsonDetailed(file) {
@@ -66,9 +179,9 @@ async function writeText(file, value) {
   await atomicWriteText(file, value);
 }
 async function atomicWriteText(file, value) {
-  const dir = path.dirname(file);
+  const dir = path5.dirname(file);
   await fs.ensureDir(dir);
-  const tempPath = path.join(
+  const tempPath = path5.join(
     dir,
     `.tmp-haus-write-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
   );
@@ -86,7 +199,7 @@ async function findNestedRepoDirs(root) {
   });
   const owners = /* @__PURE__ */ new Set();
   for (const match of matches) {
-    const owner = path.posix.dirname(match);
+    const owner = path5.posix.dirname(match);
     if (owner === "." || owner === "") continue;
     owners.add(owner);
   }
@@ -120,10 +233,10 @@ function hashText(value) {
   return `sha256-${crypto.createHash("sha256").update(value).digest("hex")}`;
 }
 function resolveContainedPath(root, rel) {
-  const resolvedRoot = path.resolve(root);
-  const resolved = path.resolve(root, rel);
+  const resolvedRoot = path5.resolve(root);
+  const resolved = path5.resolve(root, rel);
   if (resolved === resolvedRoot) return null;
-  const prefix = resolvedRoot.endsWith(path.sep) ? resolvedRoot : resolvedRoot + path.sep;
+  const prefix = resolvedRoot.endsWith(path5.sep) ? resolvedRoot : resolvedRoot + path5.sep;
   if (!resolved.startsWith(prefix)) return null;
   return resolved;
 }
@@ -171,80 +284,6 @@ var init_logger = __esm({
   }
 });
 
-// src/utils/paths.ts
-import { existsSync, readFileSync } from "node:fs";
-import os from "node:os";
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
-function hausPath(root, ...parts) {
-  return path2.join(root, HAUS_DIR, ...parts);
-}
-function claudePath(root, ...parts) {
-  return path2.join(root, ".claude", ...parts);
-}
-function claudeConfigDir() {
-  const override = process.env.CLAUDE_CONFIG_DIR;
-  if (override && override.trim().length > 0) return override;
-  return path2.join(os.homedir(), ".claude");
-}
-function defaultClaudeConfigDir() {
-  return path2.join(os.homedir(), ".claude");
-}
-function claudeConfigDirIsRelocated() {
-  return path2.resolve(claudeConfigDir()) !== path2.resolve(defaultClaudeConfigDir());
-}
-function claudeConfigDirLabel() {
-  return claudeConfigDirIsRelocated() ? claudeConfigDir().replace(/\\/g, "/") : "~/.claude";
-}
-function displayPath(root, targetPath) {
-  const rel = path2.relative(root, targetPath).replace(/\\/g, "/");
-  if (rel && !rel.startsWith("../") && rel !== "..") {
-    return rel.startsWith("./") ? rel : `./${rel}`;
-  }
-  if (claudeConfigDirIsRelocated()) {
-    const configDir = claudeConfigDir();
-    const configRel = path2.relative(configDir, targetPath).replace(/\\/g, "/");
-    if (configRel === "") return "$CLAUDE_CONFIG_DIR";
-    if (!configRel.startsWith("../") && configRel !== "..") {
-      return `$CLAUDE_CONFIG_DIR/${configRel}`;
-    }
-  }
-  const home = os.homedir();
-  const normalized = targetPath.replace(/\\/g, "/");
-  if (home && home.trim().length > 0) {
-    const homeRel = path2.relative(home, targetPath).replace(/\\/g, "/");
-    if (homeRel && !homeRel.startsWith("../") && homeRel !== "..") {
-      return `~/${homeRel}`;
-    }
-  }
-  return normalized;
-}
-function packageRoot() {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 12; i++) {
-    const pkgPath = path2.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 = path2.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  const file = fileURLToPath(import.meta.url);
-  return path2.resolve(path2.dirname(file), "../..");
-}
-var HAUS_DIR;
-var init_paths = __esm({
-  "src/utils/paths.ts"() {
-    "use strict";
-    HAUS_DIR = ".haus-workflow";
-  }
-});
-
 // src/catalog/manifest-format.ts
 function checkManifestFormat(value, sourceLabel) {
   if (value === void 0) return { ok: true, format: 1 };
@@ -297,30 +336,6 @@ var init_constants = __esm({
   }
 });
 
-// src/catalog/path-safety.ts
-import path3 from "node:path";
-function isSafeCatalogPath(itemPath) {
-  if (!itemPath || path3.isAbsolute(itemPath) || itemPath.includes("\\")) return false;
-  const normalized = path3.normalize(itemPath);
-  return !normalized.startsWith("..") && !normalized.includes("/..");
-}
-function isSafeRelativeFilePath(rel) {
-  if (!rel || rel.startsWith("/") || rel.includes("\\") || rel.includes("//")) return false;
-  if (path3.isAbsolute(rel)) return false;
-  const normalized = path3.posix.normalize(rel.replace(/\\/g, "/"));
-  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
-}
-function safeJoin(base, itemPath) {
-  if (!isSafeCatalogPath(itemPath)) return null;
-  const resolved = path3.resolve(base, itemPath);
-  return resolved.startsWith(base + path3.sep) || resolved === base ? resolved : null;
-}
-var init_path_safety = __esm({
-  "src/catalog/path-safety.ts"() {
-    "use strict";
-  }
-});
-
 // src/utils/exec.ts
 var exec_exports = {};
 __export(exec_exports, {
@@ -499,16 +514,16 @@ var init_github_rate_limit = __esm({
 });
 
 // src/catalog/remote-catalog/http.ts
-import path4 from "node:path";
-import fs2 from "fs-extra";
-async function fetchGuarded(url, extract, headers = {}) {
+import path6 from "node:path";
+import fs3 from "fs-extra";
+async function fetchGuarded(url, extract2, headers = {}) {
   try {
     const res = await fetch(url, { headers, signal: AbortSignal.timeout(1e4) });
     if (!res.ok) {
       warn(`Catalog fetch HTTP ${res.status}: ${url}`);
       return null;
     }
-    return await extract(res);
+    return await extract2(res);
   } catch (e) {
     warn(`Catalog fetch failed (${e instanceof Error ? e.constructor.name : String(e)}): ${url}`);
     return null;
@@ -521,14 +536,14 @@ async function fetchBytes(url, headers = {}) {
   return fetchGuarded(url, async (res) => Buffer.from(await res.arrayBuffer()), headers);
 }
 async function writeTextIfChanged(dest, text) {
-  if (await fs2.pathExists(dest)) {
-    const local = await fs2.readFile(dest, "utf8");
+  if (await fs3.pathExists(dest)) {
+    const local = await fs3.readFile(dest, "utf8");
     if (local === text) return "unchanged";
-    await fs2.writeFile(dest, text, "utf8");
+    await fs3.writeFile(dest, text, "utf8");
     return "updated";
   }
-  await fs2.ensureDir(path4.dirname(dest));
-  await fs2.writeFile(dest, text, "utf8");
+  await fs3.ensureDir(path6.dirname(dest));
+  await fs3.writeFile(dest, text, "utf8");
   return "created";
 }
 var init_http = __esm({
@@ -557,7 +572,7 @@ var init_semver_tag = __esm({
 });
 
 // src/catalog/remote-catalog/project-pin.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 function isSafeRef(ref) {
   return SAFE_REF.test(ref) && !ref.split("/").includes("..");
 }
@@ -568,7 +583,7 @@ function loadProjectCatalogPin(root) {
   const file = hausPath(root, PROJECT_CONFIG_FILE);
   let raw;
   try {
-    raw = fs3.readFileSync(file, "utf8");
+    raw = fs4.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return { kind: "none" };
     return { kind: "invalid", reason: `could not be read (${message(err)})` };
@@ -638,18 +653,18 @@ var init_project_pin = __esm({
 });
 
 // src/catalog/remote-catalog/ref.ts
-import path5 from "node:path";
-import fs4 from "fs-extra";
+import path7 from "node:path";
+import fs5 from "fs-extra";
 function isTestMode() {
   return process.env["HAUS_TEST_MODE"] === "1" || process.env["NODE_ENV"] === "test";
 }
 function getCacheDir() {
-  return process.env["HAUS_CATALOG_CACHE_DIR_OVERRIDE"] ?? path5.join(claudeConfigDir(), CATALOG_CACHE_SUBDIR);
+  return process.env["HAUS_CATALOG_CACHE_DIR_OVERRIDE"] ?? path7.join(claudeConfigDir(), CATALOG_CACHE_SUBDIR);
 }
 function getBundledCatalogRef() {
   try {
-    const manifestPath2 = path5.join(packageRoot(), "library/catalog/manifest.json");
-    const raw = fs4.readFileSync(manifestPath2, "utf8");
+    const manifestPath2 = path7.join(packageRoot(), "library/catalog/manifest.json");
+    const raw = fs5.readFileSync(manifestPath2, "utf8");
     const data = JSON.parse(raw);
     if (typeof data.version === "string" && data.version) {
       return data.version.startsWith("v") ? data.version : `v${data.version}`;
@@ -794,8 +809,8 @@ var init_ref = __esm({
 });
 
 // src/catalog/remote-catalog/github-tree.ts
-import path6 from "node:path";
-import fs5 from "fs-extra";
+import path8 from "node:path";
+import fs6 from "fs-extra";
 function sanitizeRelativeFilePaths(files, label) {
   const safe = [];
   for (const rel of files) {
@@ -811,17 +826,17 @@ async function listFilesRecursive(dir, base = dir) {
   const out = [];
   let entries;
   try {
-    if (!await fs5.pathExists(dir)) return out;
-    entries = await fs5.readdir(dir, { withFileTypes: true });
+    if (!await fs6.pathExists(dir)) return out;
+    entries = await fs6.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
-    const full = path6.join(dir, entry.name);
+    const full = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive(full, base));
     } else if (entry.isFile()) {
-      out.push(path6.relative(base, full).replace(/\\/g, "/"));
+      out.push(path8.relative(base, full).replace(/\\/g, "/"));
     }
   }
   return out.sort();
@@ -1558,8 +1573,8 @@ __export(sync_exports, {
   getCacheManifestAge: () => getCacheManifestAge,
   syncRemoteCatalog: () => syncRemoteCatalog
 });
-import path8 from "node:path";
-import fs7 from "fs-extra";
+import path10 from "node:path";
+import fs8 from "fs-extra";
 function isMarkdownPath(rel) {
   return rel.toLowerCase().endsWith(".md");
 }
@@ -1597,7 +1612,7 @@ function validateMarkdownFiles(item, fetched) {
   return true;
 }
 async function directoryMatchesFetched(destDir, fetched) {
-  if (!await fs7.pathExists(destDir)) return false;
+  if (!await fs8.pathExists(destDir)) return false;
   const existing = await listFilesRecursive(destDir);
   const relSet = new Set(fetched.map((f) => f.rel));
   if (existing.length !== fetched.length) return false;
@@ -1605,30 +1620,30 @@ async function directoryMatchesFetched(destDir, fetched) {
     if (!relSet.has(rel)) return false;
   }
   for (const file of fetched) {
-    const dest = path8.join(destDir, file.rel);
-    if (!await fs7.pathExists(dest)) return false;
+    const dest = path10.join(destDir, file.rel);
+    if (!await fs8.pathExists(dest)) return false;
     if (file.kind === "text") {
-      const local = await fs7.readFile(dest, "utf8");
+      const local = await fs8.readFile(dest, "utf8");
       if (local !== file.body) return false;
     } else {
-      const local = await fs7.readFile(dest);
+      const local = await fs8.readFile(dest);
       if (!local.equals(file.body)) return false;
     }
   }
   return true;
 }
 async function writeFetchedDirectory(destDir, fetched) {
-  if (await fs7.pathExists(destDir)) {
-    await fs7.remove(destDir);
+  if (await fs8.pathExists(destDir)) {
+    await fs8.remove(destDir);
   }
-  await fs7.ensureDir(destDir);
+  await fs8.ensureDir(destDir);
   for (const file of fetched) {
-    const dest = path8.join(destDir, file.rel);
-    await fs7.ensureDir(path8.dirname(dest));
+    const dest = path10.join(destDir, file.rel);
+    await fs8.ensureDir(path10.dirname(dest));
     if (file.kind === "text") {
-      await fs7.writeFile(dest, file.body, "utf8");
+      await fs8.writeFile(dest, file.body, "utf8");
     } else {
-      await fs7.writeFile(dest, file.body);
+      await fs8.writeFile(dest, file.body);
     }
   }
 }
@@ -1670,7 +1685,7 @@ async function syncDirectoryFromPrefix(item, catalogPrefix, destDir, base, opts)
       }
     }
   }
-  const existed = await fs7.pathExists(destDir);
+  const existed = await fs8.pathExists(destDir);
   if (await directoryMatchesFetched(destDir, fetched)) {
     return "unchanged";
   }
@@ -1792,6 +1807,10 @@ async function syncOneItem(item, base) {
   }
 }
 async function syncRemoteCatalog(projectRoot) {
+  if (isOffline()) {
+    log("Offline \u2014 skipping catalog sync; using cached or bundled content.");
+    return { newItems: [], refreshed: [], unchanged: 0, failed: [], skipped: true };
+  }
   _resetBlobPathCacheForNewSync();
   clearGithubRateLimitHit();
   const fetched = await fetchRemoteManifest(projectRoot);
@@ -1812,9 +1831,9 @@ async function syncRemoteCatalog(projectRoot) {
   const cacheDir = getCacheDir();
   const catalogRef = expectedCatalogRef(projectRoot);
   try {
-    await fs7.ensureDir(cacheDir);
-    await fs7.writeFile(
-      path8.join(cacheDir, "manifest.json"),
+    await fs8.ensureDir(cacheDir);
+    await fs8.writeFile(
+      path10.join(cacheDir, "manifest.json"),
       // globalPlugins must round-trip into the cache: the cache is what `haus update`
       // and `haus rescan` read pins from, so dropping it here would make every
       // catalog pin bump invisible and pin resolution fall back to the bundled default.
@@ -1879,7 +1898,7 @@ async function syncRemoteCatalog(projectRoot) {
 }
 async function getCacheManifestAge() {
   try {
-    const stat = await fs7.stat(path8.join(getCacheDir(), "manifest.json"));
+    const stat = await fs8.stat(path10.join(getCacheDir(), "manifest.json"));
     return Date.now() - stat.mtimeMs;
   } catch {
     return null;
@@ -1893,6 +1912,7 @@ var init_sync = __esm({
     init_logger();
     init_constants();
     init_ingest_catalog();
+    init_offline();
     init_path_safety();
     init_github_rate_limit();
     init_github_tree();
@@ -1912,20 +1932,204 @@ var init_sync = __esm({
 });
 
 // src/cli.ts
+init_offline();
 import { readFileSync as readFileSync5 } from "node:fs";
-import path79 from "node:path";
+import path80 from "node:path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
-import path30 from "node:path";
 import checkbox from "@inquirer/checkbox";
 
+// src/catalog/former-ids.ts
+import path4 from "node:path";
+
+// src/catalog/install-mapping.ts
+init_paths();
+init_path_safety();
+import path3 from "node:path";
+var FLATTEN_DIR_BY_TYPE = {
+  skill: "skills",
+  agent: "agents",
+  template: "templates",
+  command: "commands"
+};
+var MIRRORED_TYPES = /* @__PURE__ */ new Set(["rule", "asset"]);
+function upstreamRelative(itemPath) {
+  const match = itemPath.replace(/\\/g, "/").match(/^sources\/[^/]+\/(.+)$/);
+  return match ? match[1] : null;
+}
+function installTargetFor(item) {
+  const type = item.type;
+  if (type === "config") {
+    return {
+      ok: false,
+      code: "scaffold-only",
+      reason: 'type "config" is installed by `haus configs`, not into .claude/'
+    };
+  }
+  const flattenDir = FLATTEN_DIR_BY_TYPE[type];
+  const mirrored = MIRRORED_TYPES.has(type);
+  if (!flattenDir && !mirrored) {
+    return {
+      ok: false,
+      code: "unknown-type",
+      reason: `type "${type}" is unknown to this haus version \u2014 upgrade the CLI to use it`
+    };
+  }
+  const itemPath = typeof item.path === "string" ? item.path : "";
+  if (!isSafeCatalogPath(itemPath)) {
+    return {
+      ok: false,
+      code: "unsafe-path",
+      reason: `path "${itemPath}" is not a safe relative catalog path`
+    };
+  }
+  if (flattenDir) {
+    return {
+      ok: true,
+      layout: "flatten",
+      relPath: `${flattenDir}/${path3.posix.basename(itemPath)}`
+    };
+  }
+  const rel = upstreamRelative(itemPath);
+  if (rel === null) {
+    return {
+      ok: false,
+      code: "not-mirrorable",
+      reason: `type "${type}" installs by mirroring its upstream path, but "${itemPath}" is not under sources/<source>/`
+    };
+  }
+  if (!isSafeRelativeFilePath(rel)) {
+    return {
+      ok: false,
+      code: "unsafe-path",
+      reason: `path "${itemPath}" escapes its own sources/<source>/ prefix`
+    };
+  }
+  return { ok: true, layout: "mirror", relPath: rel };
+}
+function installDestinationFor(root, item) {
+  const target = installTargetFor(item);
+  if (!target.ok) return target;
+  const destination = safeJoin(claudePath(root), target.relPath);
+  if (destination === null) {
+    return {
+      ok: false,
+      code: "unsafe-path",
+      reason: `install path "${target.relPath}" escapes .claude/`
+    };
+  }
+  return { ok: true, layout: target.layout, relPath: target.relPath, destination };
+}
+
+// src/catalog/former-ids.ts
+function normalizeFormerIds(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length === 0) return [];
+  if (!value.every((entry) => typeof entry === "string")) return [];
+  return value.filter((entry) => entry.length > 0);
+}
+function assertFormerIdsShape(itemId, formerIds) {
+  if (formerIds === void 0) return;
+  if (Array.isArray(formerIds) && formerIds.length === 0) return;
+  if (!Array.isArray(formerIds) || !formerIds.every((entry) => typeof entry === "string")) {
+    throw new Error(`${itemId}: formerIds must be a string array`);
+  }
+}
+function buildFormerIdMap(items) {
+  const map = /* @__PURE__ */ new Map();
+  const currentIds = new Set(items.map((item) => item.id));
+  for (const item of items) {
+    assertFormerIdsShape(item.id, item.formerIds);
+    const formerIds = item.formerIds ?? [];
+    if (!Array.isArray(formerIds) || formerIds.length === 0) continue;
+    for (const formerId of formerIds) {
+      if (currentIds.has(formerId) && formerId !== item.id) {
+        throw new Error(
+          `formerId ${formerId} on ${item.id} conflicts with another item's current id`
+        );
+      }
+      const existingOwner = map.get(formerId);
+      if (existingOwner !== void 0) {
+        throw new Error(
+          `duplicate formerId ${formerId} claimed by both ${existingOwner} and ${item.id}`
+        );
+      }
+      map.set(formerId, item.id);
+    }
+  }
+  return map;
+}
+function findFormerIdMigrations(lockItems, manifestItems) {
+  const formerIdMap = buildFormerIdMap(manifestItems);
+  return lockItems.flatMap(({ id }) => {
+    const newId = formerIdMap.get(id);
+    return newId === void 0 ? [] : [{ oldId: id, newId }];
+  });
+}
+function buildFormerInstallNames(items) {
+  const names = [];
+  for (const item of items) {
+    const formerIds = normalizeFormerIds(item.formerIds);
+    if (formerIds.length === 0) continue;
+    const target = installTargetFor({ type: item.type, path: item.path });
+    if (!target.ok || target.layout !== "flatten") continue;
+    const dir = path4.posix.dirname(target.relPath);
+    const base = path4.posix.basename(target.relPath);
+    const ext = path4.posix.extname(base);
+    const currentName = ext.length > 0 ? base.slice(0, -ext.length) : base;
+    if (currentName.length === 0 || !item.id.endsWith(currentName)) continue;
+    const prefix = item.id.slice(0, item.id.length - currentName.length);
+    for (const formerId of formerIds) {
+      if (!formerId.startsWith(prefix)) continue;
+      const candidate = formerId.slice(prefix.length);
+      if (candidate.length === 0 || candidate === currentName) continue;
+      names.push({ formerId, currentId: item.id, dir, ext, candidate });
+    }
+  }
+  return names;
+}
+
+// src/catalog/installable.ts
+init_fs();
+init_paths();
+init_path_safety();
+import fs2 from "fs-extra";
+function installableRecommendedItems(recommended) {
+  return recommended.filter((item) => item.install !== false);
+}
+async function countInstallableItems(ctx, ids) {
+  const wanted = ids === void 0 ? ctx.items : ctx.items.filter((item) => ids.includes(item.id));
+  const byId = new Map(ctx.items.map((item) => [item.id, item]));
+  const missing = [];
+  let installable = 0;
+  for (const item of wanted) {
+    const contentPath = typeof item.path === "string" ? safeJoin(ctx.contentRoot, item.path) : null;
+    if (contentPath !== null && await fs2.pathExists(contentPath)) {
+      installable += 1;
+    } else {
+      missing.push(item.id);
+    }
+  }
+  if (ids !== void 0) {
+    for (const id of ids) if (!byId.has(id)) missing.push(id);
+  }
+  return { installable, missing };
+}
+async function recountInstalledAgainstLock(root, wantedIds) {
+  const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
+  const installedIds = new Set(lock.map((entry) => entry.id));
+  const installedCount = wantedIds.filter((id) => installedIds.has(id)).length;
+  const missingWantedIds = wantedIds.filter((id) => !installedIds.has(id));
+  return { installedCount, missingWantedIds };
+}
+
 // src/catalog/load-catalog.ts
 init_fs();
 init_logger();
 init_paths();
 init_manifest_format();
-import path9 from "node:path";
+import path11 from "node:path";
 
 // src/catalog/remote-catalog.ts
 init_github_tree();
@@ -1935,18 +2139,23 @@ init_project_pin();
 init_manifest();
 
 // src/catalog/remote-catalog/workflow-template.ts
+init_offline();
 init_http();
 init_ref();
-import path7 from "node:path";
-import fs6 from "fs-extra";
+import path9 from "node:path";
+import fs7 from "fs-extra";
 var WORKFLOW_TEMPLATE_REL = "templates/agentic-workflow-standard.md";
 async function readWorkflowTemplate(opts = {}) {
-  const dest = path7.join(getCacheDir(), WORKFLOW_TEMPLATE_REL);
+  const dest = path9.join(getCacheDir(), WORKFLOW_TEMPLATE_REL);
+  if (isOffline()) {
+    if (await fs7.pathExists(dest)) return fs7.readFile(dest, "utf8");
+    return null;
+  }
   const base = await remoteBase(opts.projectRoot);
   const { url, headers } = await catalogContentRequest(base, WORKFLOW_TEMPLATE_REL);
   const text = await fetchText(url, headers);
   if (text === null) {
-    if (await fs6.pathExists(dest)) return fs6.readFile(dest, "utf8");
+    if (await fs7.pathExists(dest)) return fs7.readFile(dest, "utf8");
     return null;
   }
   if (!opts.dryRun) {
@@ -1960,6 +2169,9 @@ init_github_tree();
 init_sync();
 
 // src/catalog/load-catalog.ts
+function manifestVersion(raw) {
+  return typeof raw === "string" && raw !== "" ? raw : null;
+}
 function cacheRefMatches(cached, expected) {
   if (expected === null) return true;
   if (typeof cached !== "string" || cached === "") return true;
@@ -1971,14 +2183,15 @@ async function loadCatalogContext(root) {
     const data2 = await readJson(envPath);
     return {
       items: data2?.items ?? [],
-      contentRoot: path9.dirname(envPath),
+      contentRoot: path11.dirname(envPath),
       source: "fixture",
       manifestFormat: assertSupportedManifestFormat(data2?.manifestFormat, "The fixture catalog"),
+      version: manifestVersion(data2?.version),
       globalPlugins: data2?.globalPlugins
     };
   }
   const cacheDir = getCacheDir();
-  const cacheManifestPath = path9.join(cacheDir, "manifest.json");
+  const cacheManifestPath = path11.join(cacheDir, "manifest.json");
   const cacheData = await readJson(cacheManifestPath);
   if (cacheData?.items?.length) {
     const wantedRef = expectedCatalogRef(root);
@@ -1995,31 +2208,34 @@ async function loadCatalogContext(root) {
           cacheData.manifestFormat,
           "The cached catalog"
         ),
+        version: manifestVersion(cacheData.version),
         globalPlugins: cacheData.globalPlugins
       };
     }
   }
-  const localManifest = path9.join(root, "library/catalog/manifest.json");
+  const localManifest = path11.join(root, "library/catalog/manifest.json");
   const localData = await readJson(localManifest);
   if (localData?.items?.length) {
     return {
       items: localData.items,
-      contentRoot: path9.dirname(localManifest),
+      contentRoot: path11.dirname(localManifest),
       source: "local",
       manifestFormat: assertSupportedManifestFormat(
         localData.manifestFormat,
         "The project-local catalog"
       ),
+      version: manifestVersion(localData.version),
       globalPlugins: localData.globalPlugins
     };
   }
-  const packageManifest = path9.join(packageRoot(), "library/catalog/manifest.json");
+  const packageManifest = path11.join(packageRoot(), "library/catalog/manifest.json");
   const data = await readJson(packageManifest);
   return {
     items: data?.items ?? [],
-    contentRoot: path9.dirname(packageManifest),
+    contentRoot: path11.dirname(packageManifest),
     source: "bundled",
     manifestFormat: assertSupportedManifestFormat(data?.manifestFormat, "The bundled catalog"),
+    version: manifestVersion(data?.version),
     globalPlugins: data?.globalPlugins
   };
 }
@@ -2037,9 +2253,12 @@ async function loadCatalog(root) {
   return ctx.items;
 }
 function catalogItemContentPath(contentRoot, item) {
-  return path9.join(contentRoot, item.path);
+  return path11.join(contentRoot, item.path);
 }
 
+// src/commands/apply.ts
+init_offline();
+
 // src/claude/gitignore-owned-check.ts
 init_exec();
 var HAUS_OWNED_TRACKED_PATHS = [
@@ -2061,171 +2280,19 @@ async function findGitignoredHausPaths(root) {
         result.stdout.split("\n").map((line2) => line2.trim()).filter(Boolean)
       )
     ];
-  } catch {
-    return [];
-  }
-}
-function summarizeGitignoredHausDirs(paths) {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const p of paths) dirs.add(p === ".haus-workflow" ? ".haus-workflow/" : ".claude/");
-  return [...dirs];
-}
-
-// src/claude/write-claude-files.ts
-import path25 from "node:path";
-import fs22 from "fs-extra";
-
-// src/catalog/former-ids.ts
-import path11 from "node:path";
-
-// src/catalog/install-mapping.ts
-init_paths();
-init_path_safety();
-import path10 from "node:path";
-var FLATTEN_DIR_BY_TYPE = {
-  skill: "skills",
-  agent: "agents",
-  template: "templates",
-  command: "commands"
-};
-var MIRRORED_TYPES = /* @__PURE__ */ new Set(["rule", "asset"]);
-function upstreamRelative(itemPath) {
-  const match = itemPath.replace(/\\/g, "/").match(/^sources\/[^/]+\/(.+)$/);
-  return match ? match[1] : null;
-}
-function installTargetFor(item) {
-  const type = item.type;
-  if (type === "config") {
-    return {
-      ok: false,
-      code: "scaffold-only",
-      reason: 'type "config" is installed by `haus configs`, not into .claude/'
-    };
-  }
-  const flattenDir = FLATTEN_DIR_BY_TYPE[type];
-  const mirrored = MIRRORED_TYPES.has(type);
-  if (!flattenDir && !mirrored) {
-    return {
-      ok: false,
-      code: "unknown-type",
-      reason: `type "${type}" is unknown to this haus version \u2014 upgrade the CLI to use it`
-    };
-  }
-  const itemPath = typeof item.path === "string" ? item.path : "";
-  if (!isSafeCatalogPath(itemPath)) {
-    return {
-      ok: false,
-      code: "unsafe-path",
-      reason: `path "${itemPath}" is not a safe relative catalog path`
-    };
-  }
-  if (flattenDir) {
-    return {
-      ok: true,
-      layout: "flatten",
-      relPath: `${flattenDir}/${path10.posix.basename(itemPath)}`
-    };
-  }
-  const rel = upstreamRelative(itemPath);
-  if (rel === null) {
-    return {
-      ok: false,
-      code: "not-mirrorable",
-      reason: `type "${type}" installs by mirroring its upstream path, but "${itemPath}" is not under sources/<source>/`
-    };
-  }
-  if (!isSafeRelativeFilePath(rel)) {
-    return {
-      ok: false,
-      code: "unsafe-path",
-      reason: `path "${itemPath}" escapes its own sources/<source>/ prefix`
-    };
-  }
-  return { ok: true, layout: "mirror", relPath: rel };
-}
-function installDestinationFor(root, item) {
-  const target = installTargetFor(item);
-  if (!target.ok) return target;
-  const destination = safeJoin(claudePath(root), target.relPath);
-  if (destination === null) {
-    return {
-      ok: false,
-      code: "unsafe-path",
-      reason: `install path "${target.relPath}" escapes .claude/`
-    };
-  }
-  return { ok: true, layout: target.layout, relPath: target.relPath, destination };
-}
-
-// src/catalog/former-ids.ts
-function normalizeFormerIds(value) {
-  if (value === void 0 || value === null) return [];
-  if (!Array.isArray(value) || value.length === 0) return [];
-  if (!value.every((entry) => typeof entry === "string")) return [];
-  return value.filter((entry) => entry.length > 0);
-}
-function assertFormerIdsShape(itemId, formerIds) {
-  if (formerIds === void 0) return;
-  if (Array.isArray(formerIds) && formerIds.length === 0) return;
-  if (!Array.isArray(formerIds) || !formerIds.every((entry) => typeof entry === "string")) {
-    throw new Error(`${itemId}: formerIds must be a string array`);
-  }
-}
-function buildFormerIdMap(items) {
-  const map = /* @__PURE__ */ new Map();
-  const currentIds = new Set(items.map((item) => item.id));
-  for (const item of items) {
-    assertFormerIdsShape(item.id, item.formerIds);
-    const formerIds = item.formerIds ?? [];
-    if (!Array.isArray(formerIds) || formerIds.length === 0) continue;
-    for (const formerId of formerIds) {
-      if (currentIds.has(formerId) && formerId !== item.id) {
-        throw new Error(
-          `formerId ${formerId} on ${item.id} conflicts with another item's current id`
-        );
-      }
-      const existingOwner = map.get(formerId);
-      if (existingOwner !== void 0) {
-        throw new Error(
-          `duplicate formerId ${formerId} claimed by both ${existingOwner} and ${item.id}`
-        );
-      }
-      map.set(formerId, item.id);
-    }
+  } catch {
+    return [];
   }
-  return map;
-}
-function findFormerIdMigrations(lockItems, manifestItems) {
-  const formerIdMap = buildFormerIdMap(manifestItems);
-  return lockItems.flatMap(({ id }) => {
-    const newId = formerIdMap.get(id);
-    return newId === void 0 ? [] : [{ oldId: id, newId }];
-  });
 }
-function buildFormerInstallNames(items) {
-  const names = [];
-  for (const item of items) {
-    const formerIds = normalizeFormerIds(item.formerIds);
-    if (formerIds.length === 0) continue;
-    const target = installTargetFor({ type: item.type, path: item.path });
-    if (!target.ok || target.layout !== "flatten") continue;
-    const dir = path11.posix.dirname(target.relPath);
-    const base = path11.posix.basename(target.relPath);
-    const ext = path11.posix.extname(base);
-    const currentName = ext.length > 0 ? base.slice(0, -ext.length) : base;
-    if (currentName.length === 0 || !item.id.endsWith(currentName)) continue;
-    const prefix = item.id.slice(0, item.id.length - currentName.length);
-    for (const formerId of formerIds) {
-      if (!formerId.startsWith(prefix)) continue;
-      const candidate = formerId.slice(prefix.length);
-      if (candidate.length === 0 || candidate === currentName) continue;
-      names.push({ formerId, currentId: item.id, dir, ext, candidate });
-    }
-  }
-  return names;
+function summarizeGitignoredHausDirs(paths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const p of paths) dirs.add(p === ".haus-workflow" ? ".haus-workflow/" : ".claude/");
+  return [...dirs];
 }
 
 // src/claude/write-claude-files.ts
+import path25 from "node:path";
+import fs23 from "fs-extra";
 init_ingest_catalog();
 
 // src/recommender/orphaned-items.ts
@@ -2451,7 +2518,7 @@ function isSupersededByPlugin(lockId, activePinIds) {
 
 // src/scanner/detect-package-manager.ts
 import path13 from "node:path";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 
 // src/utils/versions.ts
 import semver from "semver";
@@ -2499,16 +2566,16 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs8.existsSync(path13.join(root, "yarn.lock"))) return "yarn";
-  if (fs8.existsSync(path13.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs8.existsSync(path13.join(root, "package-lock.json"))) return "npm";
+  if (fs9.existsSync(path13.join(root, "yarn.lock"))) return "yarn";
+  if (fs9.existsSync(path13.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs9.existsSync(path13.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
 // src/update/hash-installed.ts
 import path15 from "node:path";
 import fg3 from "fast-glob";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 
 // src/claude/haus-managed-header.ts
 function parseHausManagedAttrs(line2) {
@@ -2551,7 +2618,7 @@ init_logger();
 init_paths();
 import path14 from "node:path";
 import fg2 from "fast-glob";
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 var SUPERPOWERS_ORIGIN_SOURCE_ID = "superpowers-pcvelz";
 var SUPERPOWERS_SHARED_INSTALL_REL = ".claude/skills/shared";
 var PATH_REWRITES = [
@@ -2574,10 +2641,10 @@ async function rewriteMarkdownTree(dir) {
   const files = await fg2("**/*.md", { cwd: dir, onlyFiles: true, dot: true });
   for (const rel of files) {
     const abs = path14.join(dir, rel);
-    const text = await fs9.readFile(abs, "utf8");
+    const text = await fs10.readFile(abs, "utf8");
     const rewritten = rewriteSuperpowersMarkdown(text);
     if (rewritten !== text) {
-      await fs9.writeFile(abs, rewritten, "utf8");
+      await fs10.writeFile(abs, rewritten, "utf8");
     }
   }
 }
@@ -2591,40 +2658,40 @@ async function extraDestFiles(sourcePath, destination) {
 }
 async function installCatalogSkill(sourcePath, destination, opts) {
   if (opts.dryRun) return;
-  await fs9.ensureDir(path14.dirname(destination));
-  if (await fs9.pathExists(destination)) {
+  await fs10.ensureDir(path14.dirname(destination));
+  if (await fs10.pathExists(destination)) {
     const extra = await extraDestFiles(sourcePath, destination);
     if (extra.length > 0) {
       warn(
         `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
       );
     }
-    for (const entry of await fs9.readdir(destination)) {
+    for (const entry of await fs10.readdir(destination)) {
       if (SKILL_DEP_ARTIFACT_DIRS.has(entry)) continue;
-      await fs9.remove(path14.join(destination, entry));
+      await fs10.remove(path14.join(destination, entry));
     }
   }
-  await fs9.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+  await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
   if (opts.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID) {
     await rewriteMarkdownTree(destination);
   }
 }
 async function installSuperpowersShared(contentRoot, projectRoot, dryRun) {
   const source = path14.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
-  if (!await fs9.pathExists(source)) return null;
+  if (!await fs10.pathExists(source)) return null;
   const destination = claudePath(projectRoot, "skills", "shared");
   if (dryRun) return path14.relative(projectRoot, destination);
-  await fs9.ensureDir(path14.dirname(destination));
-  if (await fs9.pathExists(destination)) {
+  await fs10.ensureDir(path14.dirname(destination));
+  if (await fs10.pathExists(destination)) {
     const extra = await extraDestFiles(source, destination);
     if (extra.length > 0) {
       warn(
         `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
       );
     }
-    await fs9.remove(destination);
+    await fs10.remove(destination);
   }
-  await fs9.copy(source, destination, { overwrite: true, errorOnExist: false });
+  await fs10.copy(source, destination, { overwrite: true, errorOnExist: false });
   await rewriteMarkdownTree(destination);
   return path14.relative(projectRoot, destination);
 }
@@ -2649,11 +2716,11 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
   const fileDigests = [];
   for (const rel of normalized) {
     const abs = path15.join(root, rel);
-    if (!await fs10.pathExists(abs)) continue;
-    const stat = followSymlinks ? await fs10.stat(abs) : await fs10.lstat(abs);
+    if (!await fs11.pathExists(abs)) continue;
+    const stat = followSymlinks ? await fs11.stat(abs) : await fs11.lstat(abs);
     if (!followSymlinks && stat.isSymbolicLink()) continue;
     if (stat.isFile()) {
-      const body = await fs10.readFile(abs);
+      const body = await fs11.readFile(abs);
       fileDigests.push({ rel, digest: digestFileContent(body) });
       continue;
     }
@@ -2674,9 +2741,9 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
     });
     for (const sub of inner.sort()) {
       const absFile = path15.join(abs, sub);
-      if (!followSymlinks && (await fs10.lstat(absFile)).isSymbolicLink()) continue;
+      if (!followSymlinks && (await fs11.lstat(absFile)).isSymbolicLink()) continue;
       const relFile = path15.join(rel, sub).replace(/\\/g, "/");
-      const body = await fs10.readFile(absFile);
+      const body = await fs11.readFile(absFile);
       fileDigests.push({ rel: relFile, digest: digestFileContent(body) });
     }
   }
@@ -2715,15 +2782,15 @@ init_logger();
 init_paths();
 
 // src/claude/managed-write.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
 async function writeManagedText(root, filePath, nextText, dryRun, quiet = false) {
   const say = quiet ? () => {
   } : log;
-  const existed = await fs11.pathExists(filePath);
-  const prev = existed ? await fs11.readFile(filePath, "utf8") : "";
+  const existed = await fs12.pathExists(filePath);
+  const prev = existed ? await fs12.readFile(filePath, "utf8") : "";
   const printable = displayPath(root, filePath);
   if (dryRun) {
     if (!existed) {
@@ -2759,7 +2826,7 @@ function buildAllowRules() {
 // src/install/settings-merge.ts
 init_fs();
 import path17 from "node:path";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 
 // src/install/manifest.ts
 init_fs();
@@ -3000,7 +3067,7 @@ function stripHausAsk(settings) {
 async function loadHooksFragment(fragmentPath) {
   let raw;
   try {
-    raw = await fs12.readJson(fragmentPath);
+    raw = await fs13.readJson(fragmentPath);
   } catch {
     return [];
   }
@@ -3050,8 +3117,8 @@ function buildDenyRules() {
   for (const command of DENY_COMMANDS) {
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path80 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path80) ? `${path80}/**` : path80;
+  for (const path81 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path81) ? `${path81}/**` : path81;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -3134,9 +3201,33 @@ async function applyProjectSettingsMerge(root) {
 
 // src/claude/remove-items.ts
 import path18 from "node:path";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 init_fs();
 init_paths();
+
+// src/claude/backup-kinds.ts
+var DIR_BACKUP_PREFIXES = {
+  undo: "undo",
+  prune: "prune",
+  remove: "remove",
+  migrate: "migrate"
+};
+var LOCK_BACKUP_RE = /^haus\.lock\.\d+\.json$/;
+function dirBackupDirName(kind, stamp) {
+  return `${DIR_BACKUP_PREFIXES[kind]}-${stamp}`;
+}
+function lockBackupFileName(epochMs) {
+  return `haus.lock.${epochMs}.json`;
+}
+function classifyBackupName(name) {
+  if (LOCK_BACKUP_RE.test(name)) return "lock";
+  for (const kind of Object.keys(DIR_BACKUP_PREFIXES)) {
+    if (name.startsWith(`${DIR_BACKUP_PREFIXES[kind]}-`)) return kind;
+  }
+  return void 0;
+}
+
+// src/claude/remove-items.ts
 async function resolveExistingTrackedPaths(root, itemId, relPaths, warnFn) {
   const existing = [];
   for (const rel of relPaths) {
@@ -3145,7 +3236,7 @@ async function resolveExistingTrackedPaths(root, itemId, relPaths, warnFn) {
       warnFn(`Refusing to touch ${itemId}'s recorded path outside the project root: ${rel}`);
       continue;
     }
-    if (await fs13.pathExists(abs)) existing.push({ rel, abs });
+    if (await fs14.pathExists(abs)) existing.push({ rel, abs });
   }
   return existing;
 }
@@ -3161,13 +3252,13 @@ async function hashGateEntry(root, entry, existing) {
 async function backupTrackedPaths(root, absPaths, say, prefix) {
   if (absPaths.length === 0) return null;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupRoot = hausPath(root, "backups", `${prefix}-${stamp}`);
+  const backupRoot = hausPath(root, "backups", dirBackupDirName(prefix, stamp));
   for (const abs of absPaths) {
-    if (!await fs13.pathExists(abs)) continue;
+    if (!await fs14.pathExists(abs)) continue;
     const rel = path18.relative(root, abs);
     const backupPath = path18.join(backupRoot, rel);
-    await fs13.ensureDir(path18.dirname(backupPath));
-    await fs13.copy(abs, backupPath);
+    await fs14.ensureDir(path18.dirname(backupPath));
+    await fs14.copy(abs, backupPath);
   }
   say(
     `Backed up ${absPaths.length} path(s) to ${path18.relative(root, backupRoot)} before deleting them.`
@@ -3176,7 +3267,7 @@ async function backupTrackedPaths(root, absPaths, say, prefix) {
 }
 async function deleteTrackedPaths(root, itemId, existing, { verb, reason }, say) {
   for (const { abs } of existing) {
-    await fs13.remove(abs);
+    await fs14.remove(abs);
     await pruneEmptyDir(path18.dirname(abs));
     say([verb, reason, displayPath(root, abs)].filter(Boolean).join(" ") + ` (${itemId})`);
   }
@@ -3185,7 +3276,7 @@ async function deleteTrackedPaths(root, itemId, existing, { verb, reason }, say)
 // src/claude/skill-dep-install.ts
 init_exec();
 import path19 from "node:path";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 function skillDepInstallCommand(manager) {
   switch (manager) {
     case "npm":
@@ -3222,7 +3313,7 @@ function skillDepInstallCommand(manager) {
 }
 async function hasDeclaredDependencies(dir) {
   try {
-    const raw = await fs14.readFile(path19.join(dir, "package.json"), "utf8");
+    const raw = await fs15.readFile(path19.join(dir, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return false;
     const deps = parsed.dependencies;
@@ -3234,7 +3325,7 @@ async function hasDeclaredDependencies(dir) {
 }
 async function realpathOrSelf(target) {
   try {
-    return await fs14.realpath(target);
+    return await fs15.realpath(target);
   } catch {
     return path19.resolve(target);
   }
@@ -3279,7 +3370,7 @@ async function installSkillDependencies(opts, deps = {}) {
     default:
       return assertNeverCommandProbe(probe);
   }
-  if (!await fs14.pathExists(contained.dir)) {
+  if (!await fs15.pathExists(contained.dir)) {
     return { status: "skipped", reason: `install directory disappeared (${contained.dir})` };
   }
   const run = deps.run ?? defaultRun;
@@ -3293,7 +3384,7 @@ async function installSkillDependencies(opts, deps = {}) {
 // src/claude/verify-hooks-contract.ts
 init_fs();
 init_paths();
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 
 // src/claude/load-hooks.ts
 var CANONICAL_HOOKS = {
@@ -3377,7 +3468,7 @@ async function assertPostApplySettingsHausContract(root) {
 }
 async function verifyProjectSettingsHooksContract(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs15.pathExists(settingsPath)) {
+  if (!await fs16.pathExists(settingsPath)) {
     return {
       ok: true,
       skipped: true,
@@ -3405,7 +3496,7 @@ async function verifyProjectSettingsHooksContract(root) {
 
 // src/claude/write-decisions-seed.ts
 import path20 from "node:path";
-import fs16 from "fs-extra";
+import fs17 from "fs-extra";
 
 // library/catalog/decisions-triggers.json
 var decisions_triggers_default = {
@@ -3450,15 +3541,15 @@ Why we chose X \u2014 short, dated, write-once decision log for humans and agent
 async function writeDecisionsSeed(root, dryRun, quiet = false) {
   const decisionsDir = path20.join(root, DECISIONS_TRIGGERS.decisionsDir);
   const readmePath = path20.join(decisionsDir, "README.md");
-  if (await fs16.pathExists(readmePath)) return null;
-  if (!dryRun) await fs16.ensureDir(decisionsDir);
+  if (await fs17.pathExists(readmePath)) return null;
+  if (!dryRun) await fs17.ensureDir(decisionsDir);
   await writeManagedText(root, readmePath, SEED_README, dryRun, quiet);
   return readmePath;
 }
 
 // src/claude/write-prettierignore.ts
 import path21 from "node:path";
-import fs17 from "fs-extra";
+import fs18 from "fs-extra";
 var PRETTIERIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var PRETTIERIGNORE_END = "# HAUS:END haus-managed";
 var IGNORED_PATHS = [".haus-workflow/", ".claude/"];
@@ -3527,7 +3618,7 @@ ${block}
 }
 async function writePrettierIgnore(root, dryRun, quiet = false) {
   const filePath = path21.join(root, ".prettierignore");
-  const prev = await fs17.pathExists(filePath) ? await fs17.readFile(filePath, "utf8") : "";
+  const prev = await fs18.pathExists(filePath) ? await fs18.readFile(filePath, "utf8") : "";
   const next = injectPrettierIgnoreBlock(prev, buildPrettierIgnoreBlock());
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
@@ -3535,7 +3626,7 @@ async function writePrettierIgnore(root, dryRun, quiet = false) {
 
 // src/claude/write-root-claude-md.ts
 import path22 from "node:path";
-import fs18 from "fs-extra";
+import fs19 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
 var WORKSPACE_BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-workspace-imports v=1 -->";
@@ -3614,7 +3705,7 @@ ${block}
 async function writeRootClaudeMd(root, dryRun, quiet = false) {
   const filePath = path22.join(root, "CLAUDE.md");
   const block = buildImportBlock();
-  const prev = await fs18.pathExists(filePath) ? await fs18.readFile(filePath, "utf8") : "";
+  const prev = await fs19.pathExists(filePath) ? await fs19.readFile(filePath, "utf8") : "";
   const next = injectHausBlock(prev, block);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
@@ -3625,12 +3716,12 @@ init_fs();
 init_logger();
 init_paths();
 import path24 from "node:path";
-import fs20 from "fs-extra";
+import fs21 from "fs-extra";
 
 // src/claude/derive-workflow-config.ts
 init_fs();
 import path23 from "node:path";
-import fs19 from "fs-extra";
+import fs20 from "fs-extra";
 function binCmd(pm, bin, args) {
   const tail = args ? ` ${args}` : "";
   if (pm === "yarn") return `yarn ${bin}${tail}`;
@@ -3649,7 +3740,7 @@ async function deriveWorkflowConfig(root, ctx) {
     return null;
   };
   const hasDep = (name) => deps.has(name);
-  const exists = (rel) => fs19.pathExistsSync(path23.join(root, rel));
+  const exists = (rel) => fs20.pathExistsSync(path23.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;
@@ -3718,7 +3809,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   } : log;
   const destPath = hausPath(root, "workflow-config.md");
   const printable = displayPath(root, destPath);
-  const exists = await fs20.pathExists(destPath);
+  const exists = await fs21.pathExists(destPath);
   if (exists && !opts.refill) {
     if (dryRun) say(printable + ": exists (project-owned, skipping)");
     return null;
@@ -3730,7 +3821,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   };
   const values = await deriveWorkflowConfig(root, ctx);
   if (exists) {
-    const current = await fs20.readFile(destPath, "utf8");
+    const current = await fs21.readFile(destPath, "utf8");
     const refilled = refillContent(current, values);
     if (refilled === current) {
       if (dryRun) say(printable + ": no blank fields to refill");
@@ -3752,7 +3843,8 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
 }
 
 // src/claude/write-workflow.ts
-import fs21 from "fs-extra";
+init_offline();
+import fs22 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -3784,7 +3876,7 @@ async function writeWorkflow(root, pkgVersion, dryRun, force = false, quiet = fa
   const templateContent = await readWorkflowTemplate({ dryRun, projectRoot: root });
   if (templateContent === null) {
     warn(
-      `Workflow template could not be fetched from the catalog \u2014 check your network, then re-run \`haus apply --write\` (or \`haus update\`)`
+      isOffline() ? `Workflow template is not in the local catalog cache and this run is offline \u2014 run \`haus catalog bundle import <file>\` (or drop \`--offline\`), then re-run \`haus apply --write\`` : `Workflow template could not be fetched from the catalog \u2014 check your network, then re-run \`haus apply --write\` (or \`haus update\`)`
     );
     return null;
   }
@@ -3794,8 +3886,8 @@ async function writeWorkflow(root, pkgVersion, dryRun, force = false, quiet = fa
 ${templateContent}`;
   const destPath = hausPath(root, "WORKFLOW.md");
   const printable = displayPath(root, destPath);
-  if (await fs21.pathExists(destPath)) {
-    const existing = await fs21.readFile(destPath, "utf8");
+  if (await fs22.pathExists(destPath)) {
+    const existing = await fs22.readFile(destPath, "utf8");
     const firstLine = existing.split("\n")[0] ?? "";
     const parsed = parseHausManagedHeader(firstLine);
     if (!parsed) {
@@ -3839,7 +3931,7 @@ ${existingContent}`;
     }
   }
   if (dryRun) {
-    const prev = await fs21.pathExists(destPath) ? await fs21.readFile(destPath, "utf8") : "";
+    const prev = await fs22.pathExists(destPath) ? await fs22.readFile(destPath, "utf8") : "";
     if (!prev) {
       say(createUnifiedDiff(printable, "", next));
     } else {
@@ -3894,14 +3986,14 @@ function decodeIfText(buf) {
   return Buffer.from(asText, "utf8").equals(buf) ? asText : null;
 }
 async function listFilesRecursive2(dir) {
-  if (!await fs22.pathExists(dir)) return [];
+  if (!await fs23.pathExists(dir)) return [];
   const files = [];
   const walk = async (current, relPrefix) => {
-    const names = await fs22.readdir(current);
+    const names = await fs23.readdir(current);
     for (const name of names) {
       const abs = path25.join(current, name);
       const rel = relPrefix ? `${relPrefix}/${name}` : name;
-      const stat = await fs22.lstat(abs);
+      const stat = await fs23.lstat(abs);
       if (stat.isSymbolicLink()) {
         warn(`Skipping symlink in dry-run diff preview: ${rel}`);
         continue;
@@ -3918,14 +4010,14 @@ async function listFilesRecursive2(dir) {
 }
 async function logFileDryRunDiff(root, srcFile, destFile, itemId, say) {
   const printable = displayPath(root, destFile);
-  const nextBuf = await fs22.readFile(srcFile);
-  if (!await fs22.pathExists(destFile)) {
+  const nextBuf = await fs23.readFile(srcFile);
+  if (!await fs23.pathExists(destFile)) {
     say(`${printable}: would create (${itemId})`);
     const nextText2 = decodeIfText(nextBuf);
     if (nextText2 !== null) say(createUnifiedDiff(printable, "", nextText2));
     return;
   }
-  const prevBuf = await fs22.readFile(destFile);
+  const prevBuf = await fs23.readFile(destFile);
   if (prevBuf.equals(nextBuf)) {
     say(`${printable}: unchanged (${itemId})`);
     return;
@@ -3958,15 +4050,15 @@ async function logSkillDryRunDiff(root, sourcePath, destination, itemId, say) {
 }
 async function removeLegacyManagedStub(root, relPathSegments, stub, dryRun, say) {
   const target = claudePath(root, ...relPathSegments);
-  if (!await fs22.pathExists(target)) return;
-  const content2 = await fs22.readFile(target, "utf8");
+  if (!await fs23.pathExists(target)) return;
+  const content2 = await fs23.readFile(target, "utf8");
   if (content2 !== stub && content2 !== `${stub}
 ` && content2 !== `${stub}\r
 `) return;
   if (dryRun) {
     say(`[dry-run] would remove stale ${displayPath(root, target)}`);
   } else {
-    await fs22.remove(target);
+    await fs23.remove(target);
   }
 }
 async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
@@ -4072,11 +4164,11 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   ];
   for (const rel of LEGACY_PRUNED_ARTIFACTS) {
     const legacyPath = hausPath(root, rel);
-    if (await fs22.pathExists(legacyPath)) {
+    if (await fs23.pathExists(legacyPath)) {
       if (dryRun) {
         say(`[dry-run] would remove stale ${displayPath(root, legacyPath)}`);
       } else {
-        await fs22.remove(legacyPath);
+        await fs23.remove(legacyPath);
       }
     }
   }
@@ -4194,7 +4286,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     }
     const sourcePath = catalogItemContentPath(contentRoot, manifestItem);
     const destination = placement.destination;
-    if (await fs22.pathExists(sourcePath)) {
+    if (await fs23.pathExists(sourcePath)) {
       if (dryRun) {
         if (item.type === "skill") {
           await logSkillDryRunDiff(root, sourcePath, destination, item.id, say);
@@ -4221,13 +4313,13 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       )) {
         continue;
       } else if (item.type === "skill") {
-        const skillFiles = (await fs22.readdir(sourcePath, { recursive: true })).filter(
+        const skillFiles = (await fs23.readdir(sourcePath, { recursive: true })).filter(
           (f) => typeof f === "string" && f.endsWith(".md")
         );
         let skillValid = true;
         for (const relFile of skillFiles) {
           const mdPath = path25.join(sourcePath, relFile);
-          const mdContent = await fs22.readFile(mdPath, "utf8");
+          const mdContent = await fs23.readFile(mdPath, "utf8");
           const mdValidation = validateCatalogItem(
             {
               id: manifestItem.id,
@@ -4260,7 +4352,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           say
         );
       } else {
-        const fileContent = await fs22.readFile(sourcePath, "utf8");
+        const fileContent = await fs23.readFile(sourcePath, "utf8");
         const validation = validateCatalogItem(
           {
             id: manifestItem.id,
@@ -4274,8 +4366,8 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           warn(`Skipping ${item.id}: pre-copy validation failed \u2014 ${validation.reason}`);
           continue;
         }
-        await fs22.ensureDir(path25.dirname(destination));
-        await fs22.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+        await fs23.ensureDir(path25.dirname(destination));
+        await fs23.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
       const relPaths = [path25.relative(root, destination)];
@@ -4407,7 +4499,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
 async function hasProtectedUnsafePath(root, relPaths) {
   for (const rel of relPaths) {
     if (resolveContainedPath(root, rel) !== null) continue;
-    if (await fs22.pathExists(path25.resolve(root, rel))) return true;
+    if (await fs23.pathExists(path25.resolve(root, rel))) return true;
   }
   return false;
 }
@@ -4441,7 +4533,7 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
     const relPaths = entry.paths ?? [];
     const existing = await resolveExistingTrackedPaths(root, migration.oldId, relPaths, warn);
     if (existing.length === 0) continue;
-    const gate = await hashGateEntry(root, { id: migration.oldId, hash: entry.hash }, existing);
+    const gate = await hashGateEntry(root, { hash: entry.hash }, existing);
     if (!gate.ok) {
       if (gate.reason === "no-hash") {
         warn(
@@ -4468,10 +4560,10 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
     return;
   }
   const allAbsPaths = toRemove.flatMap(({ existing }) => existing.map(({ abs }) => abs));
-  await backupTrackedPaths(root, allAbsPaths, say, "migrate");
+  void await backupTrackedPaths(root, allAbsPaths, say, "migrate");
   for (const { existing } of toRemove) {
     for (const { abs } of existing) {
-      await fs22.remove(abs);
+      await fs23.remove(abs);
       await pruneEmptyDir(path25.dirname(abs));
     }
   }
@@ -4487,11 +4579,13 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
   );
   let keepShared = false;
   for (const entry of supersededEntries) {
+    const id = entry.id;
+    if (!id) continue;
     const relPaths = entry.paths ?? [];
     if (relPaths.length === 0) continue;
-    const existing = await resolveExistingTrackedPaths(root, entry.id, relPaths, warn);
+    const existing = await resolveExistingTrackedPaths(root, id, relPaths, warn);
     if (existing.length === 0) continue;
-    const gate = await hashGateEntry(root, { id: entry.id, hash: entry.hash }, existing);
+    const gate = await hashGateEntry(root, { hash: entry.hash }, existing);
     if (!gate.ok) keepShared = true;
   }
   for (const entry of prevLock) {
@@ -4503,12 +4597,15 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
     if (!removedFromManifest && !deprecated && !superseded) continue;
     const relPaths = entry.paths ?? [];
     if (relPaths.length === 0) continue;
-    if (await hasProtectedUnsafePath(root, relPaths)) refusedIds.add(entry.id);
     const existing = await resolveExistingTrackedPaths(root, entry.id, relPaths, warn);
+    if (await hasProtectedUnsafePath(root, relPaths)) {
+      refusedIds.add(entry.id);
+      continue;
+    }
     if (existing.length === 0) continue;
     const pruneReason = superseded ? "superseded" : deprecated ? "deprecated" : "stale";
     const label = superseded ? "Superseded" : deprecated ? "Deprecated" : "Stale";
-    const gate = await hashGateEntry(root, { id: entry.id, hash: entry.hash }, existing);
+    const gate = await hashGateEntry(root, { hash: entry.hash }, existing);
     if (!gate.ok) {
       if (gate.reason === "no-hash") {
         warn(
@@ -4533,7 +4630,7 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
       return true;
     }) : existing;
     if (!dryRun && removable.length > 0) {
-      await backupTrackedPaths(
+      void await backupTrackedPaths(
         root,
         removable.map((e) => e.abs),
         say,
@@ -4545,7 +4642,7 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
         say(`[dry-run] would remove ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
         continue;
       }
-      await fs22.remove(abs);
+      await fs23.remove(abs);
       await pruneEmptyDir(path25.dirname(abs));
       say(`Removed ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
     }
@@ -4563,10 +4660,13 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
     if (!entry.id) continue;
     const relPaths = entry.paths ?? [];
     if (relPaths.length === 0) continue;
-    if (await hasProtectedUnsafePath(root, relPaths)) refusedIds.add(entry.id);
     const existing = await resolveExistingTrackedPaths(root, entry.id, relPaths, warn);
+    if (await hasProtectedUnsafePath(root, relPaths)) {
+      refusedIds.add(entry.id);
+      continue;
+    }
     if (existing.length === 0) continue;
-    const gate = await hashGateEntry(root, { id: entry.id, hash: entry.hash }, existing);
+    const gate = await hashGateEntry(root, { hash: entry.hash }, existing);
     if (!gate.ok) {
       const detail = gate.reason === "no-hash" ? "has no lock hash" : "was modified locally";
       warn(
@@ -4587,7 +4687,7 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
     return refusedIds;
   }
   const allAbsPaths = toRemove.flatMap(({ existing }) => existing.map(({ abs }) => abs));
-  await backupTrackedPaths(root, allAbsPaths, say, "prune");
+  void await backupTrackedPaths(root, allAbsPaths, say, "prune");
   for (const { id, existing } of toRemove) {
     await deleteTrackedPaths(root, id, existing, { verb: "Pruned", reason: "orphaned" }, say);
   }
@@ -4597,14 +4697,15 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
 // src/claude/write-gitignore.ts
 init_exec();
 import path26 from "node:path";
-import fs23 from "fs-extra";
+import fs24 from "fs-extra";
 var GITIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var GITIGNORE_END = "# HAUS:END haus-managed";
 var GITIGNORED_ARTIFACT_PATHS = [
   ".haus-workflow/context-map.json",
   ".haus-workflow/recommendation.json",
   ".haus-workflow/sources-report.json",
-  ".haus-workflow/deep-context.json"
+  ".haus-workflow/deep-context.json",
+  ".haus-workflow/backups/"
 ];
 function findLineMarker3(content2, marker, from = 0) {
   let idx = content2.indexOf(marker, from);
@@ -4649,7 +4750,7 @@ function buildBlockFor(existing, beginMarker, endMarker, comment, patterns) {
   if (needed.length === 0) return null;
   return [beginMarker, comment, ...needed, endMarker].join("\n");
 }
-var ARTIFACT_BLOCK_COMMENT = "# haus scan artifacts \u2014 machine-local, must never be committed (see ADR-0025)";
+var ARTIFACT_BLOCK_COMMENT = "# haus machine-local artifacts \u2014 must never be committed (see ADR-0025, ADR-0058)";
 function injectBlockFor(existing, beginMarker, endMarker, comment, patterns) {
   const block = buildBlockFor(existing, beginMarker, endMarker, comment, patterns);
   const range = findBlockRangeFor(existing, beginMarker, endMarker);
@@ -4712,14 +4813,14 @@ function injectLinkContextGitignoreBlock(existing) {
 }
 async function writeGitignore(root, dryRun, quiet = false) {
   const filePath = path26.join(root, ".gitignore");
-  const prev = await fs23.pathExists(filePath) ? await fs23.readFile(filePath, "utf8") : "";
+  const prev = await fs24.pathExists(filePath) ? await fs24.readFile(filePath, "utf8") : "";
   const next = injectGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
 }
 async function writeLinkContextGitignore(root, dryRun, quiet = false) {
   const filePath = path26.join(root, ".gitignore");
-  const prev = await fs23.pathExists(filePath) ? await fs23.readFile(filePath, "utf8") : "";
+  const prev = await fs24.pathExists(filePath) ? await fs24.readFile(filePath, "utf8") : "";
   const next = injectLinkContextGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
@@ -4742,7 +4843,7 @@ async function untrackMachineLocalArtifacts(root, dryRun, notify) {
   for (const rel of tracked) {
     if (dryRun) {
       notify(
-        `Would untrack ${rel} from git \u2014 it contains machine-local scan output and should never have been committed.`
+        `Would untrack ${rel} from git \u2014 it is machine-local haus output and should never have been committed.`
       );
       continue;
     }
@@ -4750,7 +4851,7 @@ async function untrackMachineLocalArtifacts(root, dryRun, notify) {
     if (result.exitCode === 0) {
       untracked.push(rel);
       notify(
-        `Untracked ${rel} from git \u2014 it contains machine-local scan output and should never have been committed. Run \`git status\` to review before committing this change.`
+        `Untracked ${rel} from git \u2014 it is machine-local haus output and should never have been committed. Run \`git status\` to review before committing this change.`
       );
     } else {
       notify(`Could not untrack ${rel} from git: ${result.stderr.trim() || result.stdout.trim()}`);
@@ -4761,6 +4862,7 @@ async function untrackMachineLocalArtifacts(root, dryRun, notify) {
 
 // src/install/ensure-global-plugins.ts
 import path27 from "node:path";
+init_offline();
 init_exec();
 init_fs();
 init_logger();
@@ -4941,6 +5043,9 @@ var EXEC_ENV = { GIT_TERMINAL_PROMPT: "0" };
 function globalPluginsDisabled() {
   return process.env.HAUS_NO_GLOBAL_PLUGINS === "1";
 }
+function globalPluginMutationsDisabled() {
+  return globalPluginsDisabled() || isOffline();
+}
 var realExec = (args) => runCommand("claude", args, {
   timeout: EXEC_TIMEOUT_MS,
   env: EXEC_ENV,
@@ -5084,7 +5189,7 @@ async function ensureGlobalPlugins(pins, deps = {}) {
   const log2 = deps.log ?? log;
   const warn2 = deps.warn ?? warn;
   const dryRun = deps.dryRun ?? false;
-  if (globalPluginsDisabled() && deps.exec === void 0) {
+  if (globalPluginMutationsDisabled() && deps.exec === void 0) {
     return { actions: [], ensured: [], failed: [], unavailable: true, restartRequired: false };
   }
   const state = await probePluginEnv(deps);
@@ -5153,7 +5258,7 @@ async function removeGlobalPlugins(plugins, deps = {}) {
   const log2 = deps.log ?? log;
   const result = { removed: [], failed: [], unavailable: false };
   if (plugins.length === 0) return result;
-  if (globalPluginsDisabled() && deps.exec === void 0) {
+  if (globalPluginMutationsDisabled() && deps.exec === void 0) {
     return { ...result, unavailable: true };
   }
   const state = await probePluginEnv(deps);
@@ -5202,25 +5307,25 @@ async function removeGlobalPlugins(plugins, deps = {}) {
 
 // src/refs/fetch-refs.ts
 import path29 from "node:path";
-import fs25 from "fs-extra";
+import fs26 from "fs-extra";
 
 // src/refs/cache-meta.ts
 import path28 from "node:path";
-import fs24 from "fs-extra";
+import fs25 from "fs-extra";
 var META_FILENAME = "cache-meta.json";
 async function readCacheMeta(cacheDir) {
   const metaPath = path28.join(cacheDir, META_FILENAME);
   try {
-    const raw = await fs24.readFile(metaPath, "utf8");
+    const raw = await fs25.readFile(metaPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 async function writeCacheMeta(cacheDir, meta) {
-  await fs24.ensureDir(cacheDir);
+  await fs25.ensureDir(cacheDir);
   const metaPath = path28.join(cacheDir, META_FILENAME);
-  await fs24.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await fs25.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
 }
 
 // src/refs/fetch-refs.ts
@@ -5241,7 +5346,7 @@ async function fetchSingleRef(url, cacheDir, meta) {
   const existing = meta[url];
   const headers = {};
   const safeFile = existing?.file && existing.file === path29.basename(existing.file);
-  const cachedFileExists = safeFile && await fs25.pathExists(path29.join(cacheDir, existing.file));
+  const cachedFileExists = safeFile && await fs26.pathExists(path29.join(cacheDir, existing.file));
   if (cachedFileExists) {
     if (existing?.etag) headers["If-None-Match"] = existing.etag;
     if (existing?.lastModified) headers["If-Modified-Since"] = existing.lastModified;
@@ -5252,8 +5357,8 @@ async function fetchSingleRef(url, cacheDir, meta) {
     if (!res.ok) return { result: "failed" };
     const text = await res.text();
     const file = `${urlToSlug(url)}.md`;
-    await fs25.ensureDir(cacheDir);
-    await fs25.writeFile(path29.join(cacheDir, file), text, "utf8");
+    await fs26.ensureDir(cacheDir);
+    await fs26.writeFile(path29.join(cacheDir, file), text, "utf8");
     meta[url] = {
       url,
       etag: res.headers.get("etag") ?? void 0,
@@ -5277,7 +5382,7 @@ async function pruneOrphanedRefs(cacheDir, keepUrls) {
     delete meta[url];
     removed++;
     const safeFile = typeof entry.file === "string" && entry.file === path29.basename(entry.file);
-    if (safeFile) await fs25.remove(path29.join(cacheDir, entry.file)).catch(() => {
+    if (safeFile) await fs26.remove(path29.join(cacheDir, entry.file)).catch(() => {
     });
   }
   if (removed > 0) await writeCacheMeta(cacheDir, meta);
@@ -5351,13 +5456,6 @@ function dryRunPrefix(dryRun, text) {
 
 // src/commands/apply.ts
 var STALE_CACHE_THRESHOLD_DAYS = 7;
-async function cacheHasItems() {
-  const data = await readJson(path30.join(getCacheDir(), "manifest.json"));
-  return Array.isArray(data?.items) && data.items.length > 0;
-}
-function installableRecommendedItems(recommended) {
-  return recommended.filter((item) => item.install !== false);
-}
 async function runApply(options) {
   const mode = resolveWriteMode(options, "explicit-choice");
   if (mode.kind === "unspecified") {
@@ -5374,11 +5472,11 @@ async function runApply(options) {
       process.exitCode = 1;
       return;
     }
-    const rec = await readJson(hausPath(root, "recommendation.json"));
-    const recommended = rec?.recommended ?? [];
+    const rec2 = await readJson(hausPath(root, "recommendation.json"));
+    const recommended = rec2?.recommended ?? [];
     const installableIds = new Set(installableRecommendedItems(recommended).map((i) => i.id));
     const configIds = new Set(recommended.filter((i) => i.install === false).map((i) => i.id));
-    const skippedIds = new Set((rec?.skipped ?? []).map((s) => s.id));
+    const skippedIds = new Set((rec2?.skipped ?? []).map((s) => s.id));
     for (const id of explicitIds.filter((id2) => !installableIds.has(id2))) {
       if (configIds.has(id)) {
         warn(`--ids: "${id}" is a config item \u2014 install it with \`haus configs ${id}\`. Ignoring.`);
@@ -5401,12 +5499,12 @@ async function runApply(options) {
       process.exitCode = 1;
       return;
     }
-    const rec = await readJson(hausPath(root, "recommendation.json"));
-    if (!rec) {
+    const rec2 = await readJson(hausPath(root, "recommendation.json"));
+    if (!rec2) {
       log("No recommendation.json found \u2014 run `haus recommend` first. Writing core files only.");
       selectedIds = [];
     } else {
-      const items = installableRecommendedItems(rec.recommended);
+      const items = installableRecommendedItems(rec2.recommended);
       if (items.length === 0) {
         log("Recommendation contains no catalog items. Writing core files only.");
         selectedIds = [];
@@ -5426,14 +5524,31 @@ async function runApply(options) {
       }
     }
   }
-  if (!process.env["HAUS_FIXTURE_CATALOG"]) {
-    const rec = await readJson(hausPath(root, "recommendation.json"));
-    const installableRecommended = installableRecommendedItems(rec?.recommended ?? []);
-    const catalogItemCount = selectedIds !== void 0 ? selectedIds.length : installableRecommended.length;
-    if (catalogItemCount > 0) {
-      const hasItems = await cacheHasItems();
-      if (!hasItems && !options.allowEmptyCache) {
-        const message2 = "No catalog content found. Run `haus update` first.";
+  const formatRefusal = await catalogFormatRefusal(root);
+  if (formatRefusal) {
+    error(formatRefusal);
+    process.exitCode = 1;
+    return;
+  }
+  const rec = await readJson(hausPath(root, "recommendation.json"));
+  const installableRecommended = installableRecommendedItems(rec?.recommended ?? []);
+  const wantedIds = selectedIds ?? installableRecommended.map((item) => item.id);
+  let catalogCtx = null;
+  let resolvedWantedIds = wantedIds;
+  if (wantedIds.length > 0) {
+    catalogCtx = await loadCatalogContext(root);
+    const prevLock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
+    const migrations = findFormerIdMigrations(
+      prevLock.filter((entry) => Boolean(entry.id)),
+      catalogCtx.items
+    );
+    const migrationByOldId = new Map(migrations.map((m) => [m.oldId, m.newId]));
+    resolvedWantedIds = wantedIds.map((id) => migrationByOldId.get(id) ?? id);
+    const shortfall = await countInstallableItems(catalogCtx, resolvedWantedIds);
+    const tier = `${catalogCtx.source}${catalogCtx.version ? ` (v${catalogCtx.version})` : ""}`;
+    if (shortfall.installable === 0) {
+      const message2 = "No catalog content found. Run `haus update` first.";
+      if (!options.allowEmptyCache) {
         if (isDryRun) {
           warn(`Catalog cache is empty \u2014 dry-run will skip catalog items. ${message2}`);
         } else {
@@ -5441,25 +5556,32 @@ async function runApply(options) {
           process.exitCode = 1;
           return;
         }
-      } else if (hasItems) {
-        const cacheAgeMs = await getCacheManifestAge();
-        if (cacheAgeMs !== null) {
-          const cacheAgeDays = Math.floor(cacheAgeMs / (1e3 * 60 * 60 * 24));
-          if (cacheAgeDays >= STALE_CACHE_THRESHOLD_DAYS) {
-            warn(
-              `Catalog cache is ${cacheAgeDays} days old \u2014 run \`haus update\` for the latest content.`
-            );
-          }
+      } else {
+        warn(
+          `Serving catalog metadata from the ${tier} tier, which has no installable content. Core files will be written; all ${wantedIds.length} catalog item(s) will be skipped.`
+        );
+      }
+    } else if (shortfall.missing.length > 0) {
+      warn(
+        `The ${tier} catalog tier is missing content for ${shortfall.missing.length} item(s): ${shortfall.missing.join(", ")}. They will be skipped.`
+      );
+    }
+    if (catalogCtx.source === "cache") {
+      const cacheAgeMs = await getCacheManifestAge();
+      if (cacheAgeMs !== null) {
+        const cacheAgeDays = Math.floor(cacheAgeMs / (1e3 * 60 * 60 * 24));
+        if (cacheAgeDays >= STALE_CACHE_THRESHOLD_DAYS) {
+          warn(
+            `Catalog cache is ${cacheAgeDays} days old \u2014 run \`haus update\` for the latest content.`
+          );
         }
       }
+    } else if (catalogCtx.source === "bundled") {
+      warn(
+        `Catalog is being served from the snapshot bundled with this CLI${catalogCtx.version ? ` (v${catalogCtx.version})` : ""}, frozen at publish time. Run \`haus update\` when you have network access.`
+      );
     }
   }
-  const formatRefusal = await catalogFormatRefusal(root);
-  if (formatRefusal) {
-    error(formatRefusal);
-    process.exitCode = 1;
-    return;
-  }
   const files = await writeClaudeFiles(root, isDryRun, selectedIds, {
     refillConfig: options.refillConfig,
     force: options.force,
@@ -5476,13 +5598,19 @@ async function runApply(options) {
       const installedIds = new Set(lock.map((entry) => entry.id));
       const allItems = await loadCatalog(root);
       const installedItems = allItems.filter((item) => installedIds.has(item.id));
-      const summary = await fetchRefsForItems(installedItems, cacheDir);
-      if (summary.fetched > 0)
-        log(`Fetched ${summary.fetched} llms.txt reference(s) to ${cacheDir}`);
-      if (summary.failed > 0)
-        warn(
-          `Failed to fetch ${summary.failed} llms.txt reference(s): ${summary.failedUrls.join(", ")}`
-        );
+      if (isOffline()) {
+        const refCount = collectLlmsTxtUrls(installedItems).length;
+        if (refCount > 0)
+          log(`Offline \u2014 skipping ${refCount} llms.txt reference fetch(es); using the cache as-is.`);
+      } else {
+        const summary = await fetchRefsForItems(installedItems, cacheDir);
+        if (summary.fetched > 0)
+          log(`Fetched ${summary.fetched} llms.txt reference(s) to ${cacheDir}`);
+        if (summary.failed > 0)
+          warn(
+            `Failed to fetch ${summary.failed} llms.txt reference(s): ${summary.failedUrls.join(", ")}`
+          );
+      }
       const pruned = await pruneOrphanedRefs(cacheDir, new Set(collectLlmsTxtUrls(installedItems)));
       if (pruned > 0)
         log(
@@ -5505,17 +5633,32 @@ async function runApply(options) {
   }
   if (isDryRun) {
     log(`Dry-run complete \u2014 ${files.length} file(s) planned, none written. Run --write to apply.`);
-  } else {
-    log("Applied files:");
-    files.forEach((f) => log(`- ${displayPath(root, f)}`));
+    return;
+  }
+  log("Applied files:");
+  files.forEach((f) => log(`- ${displayPath(root, f)}`));
+  if (resolvedWantedIds.length > 0) {
+    const { installedCount: installedWantedCount, missingWantedIds } = await recountInstalledAgainstLock(root, resolvedWantedIds);
+    if (missingWantedIds.length > 0) {
+      const tier = catalogCtx ? `${catalogCtx.source}${catalogCtx.version ? ` (v${catalogCtx.version})` : ""}` : "unknown";
+      log(
+        `${installedWantedCount} of ${resolvedWantedIds.length} catalog items installed (${tier} tier).`
+      );
+      if (installedWantedCount === 0) {
+        error(
+          "No catalog items were installed \u2014 only core files were written. Run `haus update` with network access, or import a catalog bundle."
+        );
+        process.exitCode = 1;
+      }
+    }
   }
 }
 
 // src/commands/backups.ts
+import path30 from "node:path";
+import fs27 from "fs-extra";
 init_logger();
 init_paths();
-import path31 from "node:path";
-import fs26 from "fs-extra";
 
 // src/utils/prompts.ts
 import { stdin, stdout } from "node:process";
@@ -5578,25 +5721,16 @@ Enter a number (1-${choices.length})`, io);
 }
 
 // src/commands/backups.ts
-var LOCK_BACKUP_RE = /^haus\.lock\.\d+\.json$/;
-function classify(name) {
-  if (LOCK_BACKUP_RE.test(name)) return "lock";
-  if (name.startsWith("undo-")) return "undo";
-  if (name.startsWith("prune-")) return "prune";
-  if (name.startsWith("remove-")) return "remove";
-  if (name.startsWith("migrate-")) return "migrate";
-  return void 0;
-}
 async function listBackups(root) {
   const dir = hausPath(root, "backups");
-  if (!await fs26.pathExists(dir)) return [];
-  const names = await fs26.readdir(dir);
+  if (!await fs27.pathExists(dir)) return [];
+  const names = await fs27.readdir(dir);
   const entries = [];
   for (const name of names) {
-    const kind = classify(name);
+    const kind = classifyBackupName(name);
     if (!kind) continue;
-    const absPath = path31.join(dir, name);
-    const stat = await fs26.lstat(absPath);
+    const absPath = path30.join(dir, name);
+    const stat = await fs27.lstat(absPath);
     if (stat.isSymbolicLink()) continue;
     const expectDirectory = kind !== "lock";
     if (stat.isDirectory() !== expectDirectory) continue;
@@ -5635,13 +5769,13 @@ async function runList(root, json) {
   }
 }
 async function isUnsafeWriteTarget(root, target) {
-  const segments = path31.relative(root, target).split(path31.sep).filter(Boolean);
+  const segments = path30.relative(root, target).split(path30.sep).filter(Boolean);
   let current = root;
   for (let i = 0; i < segments.length; i++) {
-    current = path31.join(current, segments[i]);
+    current = path30.join(current, segments[i]);
     const isLastSegment = i === segments.length - 1;
     try {
-      const stat = await fs26.lstat(current);
+      const stat = await fs27.lstat(current);
       if (isLastSegment) {
         if (!stat.isFile()) return true;
       } else if (!stat.isDirectory()) {
@@ -5656,7 +5790,7 @@ async function isUnsafeWriteTarget(root, target) {
 }
 async function lstatIfRegularFile(abs) {
   try {
-    const stat = await fs26.lstat(abs);
+    const stat = await fs27.lstat(abs);
     return stat.isFile() ? stat : null;
   } catch (err) {
     if (err.code === "ENOENT") return null;
@@ -5671,8 +5805,8 @@ async function restoreLockBackup(root, entry, yes, json, dryRun) {
     );
     return { ok: false, restored: 0 };
   }
-  if (await fs26.pathExists(target)) {
-    const targetStat = await fs26.stat(target);
+  if (await fs27.pathExists(target)) {
+    const targetStat = await fs27.stat(target);
     if (targetStat.mtimeMs > entry.mtimeMs) {
       warn(
         `Current haus.lock.json (${new Date(targetStat.mtimeMs).toISOString()}) is newer than backup ${entry.id} (${new Date(entry.mtimeMs).toISOString()}) \u2014 it will be overwritten.`
@@ -5706,7 +5840,7 @@ async function restoreLockBackup(root, entry, yes, json, dryRun) {
     error(`Refusing to restore: ${entry.id} or ${target} changed since being checked.`);
     return { ok: false, restored: 0 };
   }
-  await fs26.copy(entry.absPath, target, { overwrite: true });
+  await fs27.copy(entry.absPath, target, { overwrite: true });
   if (!json) log(`Restored .haus-workflow/haus.lock.json from ${entry.id}.`);
   return { ok: true, restored: 1 };
 }
@@ -5714,10 +5848,10 @@ async function collectFilesRecursive(dir) {
   const files = [];
   const skippedLinks = [];
   const skippedOther = [];
-  const names = await fs26.readdir(dir);
+  const names = await fs27.readdir(dir);
   for (const name of names) {
-    const abs = path31.join(dir, name);
-    const stat = await fs26.lstat(abs);
+    const abs = path30.join(dir, name);
+    const stat = await fs27.lstat(abs);
     if (stat.isSymbolicLink()) {
       skippedLinks.push(abs);
       continue;
@@ -5739,12 +5873,12 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const { files, skippedLinks, skippedOther } = await collectFilesRecursive(entry.absPath);
   if (skippedLinks.length > 0) {
     warn(
-      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path31.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path30.relative(entry.absPath, abs)).join(", ")}`
     );
   }
   if (skippedOther.length > 0) {
     warn(
-      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path31.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path30.relative(entry.absPath, abs)).join(", ")}`
     );
   }
   if (files.length === 0) {
@@ -5754,8 +5888,8 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const safeFiles = [];
   const unsafeTargets = [];
   for (const abs of files) {
-    const rel = path31.relative(entry.absPath, abs);
-    const target = path31.join(root, rel);
+    const rel = path30.relative(entry.absPath, abs);
+    const target = path30.join(root, rel);
     if (await isUnsafeWriteTarget(root, target)) unsafeTargets.push(rel);
     else safeFiles.push(abs);
   }
@@ -5772,16 +5906,16 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const vanished = [];
   const toRestore = [];
   for (const abs of safeFiles) {
-    const rel = path31.relative(entry.absPath, abs);
+    const rel = path30.relative(entry.absPath, abs);
     const backupFileStat = await lstatIfRegularFile(abs);
     if (!backupFileStat) {
       vanished.push(rel);
       continue;
     }
     toRestore.push(abs);
-    const target = path31.join(root, rel);
-    if (await fs26.pathExists(target)) {
-      const targetStat = await fs26.stat(target);
+    const target = path30.join(root, rel);
+    if (await fs27.pathExists(target)) {
+      const targetStat = await fs27.stat(target);
       if (targetStat.mtimeMs > backupFileStat.mtimeMs) {
         stale.push({
           rel,
@@ -5809,7 +5943,7 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
     );
   }
   if (dryRun) {
-    const rels = toRestore.map((abs) => path31.relative(entry.absPath, abs));
+    const rels = toRestore.map((abs) => path30.relative(entry.absPath, abs));
     if (!json) {
       log(`[dry-run] Would restore ${rels.length} file(s) from ${entry.id}:`);
       for (const rel of rels) log(`  ${rel}`);
@@ -5835,14 +5969,14 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   let restoredCount = 0;
   const skippedAtWrite = [];
   for (const abs of toRestore) {
-    const rel = path31.relative(entry.absPath, abs);
-    const target = path31.join(root, rel);
+    const rel = path30.relative(entry.absPath, abs);
+    const target = path30.join(root, rel);
     if (!await lstatIfRegularFile(abs) || await isUnsafeWriteTarget(root, target)) {
       skippedAtWrite.push(rel);
       continue;
     }
-    await fs26.ensureDir(path31.dirname(target));
-    await fs26.copy(abs, target, { overwrite: true });
+    await fs27.ensureDir(path30.dirname(target));
+    await fs27.copy(abs, target, { overwrite: true });
     restoredCount++;
   }
   if (skippedAtWrite.length > 0) {
@@ -5923,7 +6057,7 @@ Keeping ${keepCount}.`
   const failed = [];
   for (const entry of removeList) {
     try {
-      await fs26.remove(entry.absPath);
+      await fs27.remove(entry.absPath);
       removed.push(entry.id);
     } catch (err) {
       failed.push({ id: entry.id, message: err instanceof Error ? err.message : String(err) });
@@ -6017,26 +6151,272 @@ function auditForbiddenTags(items) {
       if (forbidden.has(token)) failures.push(`${item.id} has unsupported tag ${token}`);
     }
   }
-  return failures;
-}
-async function runCatalogAudit() {
-  const items = await loadCatalog(process.cwd());
-  const failures = auditForbiddenTags(items);
-  if (failures.length) {
-    failures.forEach((f) => error(f));
-    process.exitCode = 1;
-    return;
-  }
-  log("Catalog audit passed.");
+  return failures;
+}
+async function runCatalogAudit() {
+  const items = await loadCatalog(process.cwd());
+  const failures = auditForbiddenTags(items);
+  if (failures.length) {
+    failures.forEach((f) => error(f));
+    process.exitCode = 1;
+    return;
+  }
+  log("Catalog audit passed.");
+}
+
+// src/commands/catalog-bundle.ts
+init_constants();
+init_ingest_catalog();
+init_manifest_format();
+init_path_safety();
+import os2 from "node:os";
+import path31 from "node:path";
+import fs28 from "fs-extra";
+import * as tar from "tar";
+init_fs();
+init_logger();
+var BUNDLE_META_FILE = "bundle.json";
+var MANIFEST_FILE = "manifest.json";
+var SUPERPOWERS_SHARED_ITEM = {
+  id: "haus.superpowers-shared",
+  type: "skill",
+  path: SUPERPOWERS_SHARED_CATALOG_REL
+};
+async function runBundleExport(options) {
+  const out = options.out;
+  if (!out) {
+    error("Specify a destination with --out <file.tgz>");
+    process.exitCode = 1;
+    return;
+  }
+  const cacheDir = getCacheDir();
+  const manifest = await readJson(path31.join(cacheDir, MANIFEST_FILE));
+  if (!manifest?.items?.length) {
+    error("Catalog cache is empty \u2014 run `haus update` on a connected machine first.");
+    process.exitCode = 1;
+    return;
+  }
+  const meta = {
+    version: typeof manifest.version === "string" ? manifest.version : null,
+    catalogRef: typeof manifest.catalogRef === "string" ? manifest.catalogRef : null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeBundleAsTar(cacheDir, meta, path31.resolve(out));
+  log(
+    `Exported ${manifest.items.length} catalog item(s) to ${out}${meta.catalogRef ? ` (${meta.catalogRef})` : ""}.`
+  );
+  log("Move it to the disconnected machine and run `haus catalog bundle import <file>`.");
+}
+async function writeBundleAsTar(cacheDir, meta, dest) {
+  const bundleMetaPath = path31.join(cacheDir, BUNDLE_META_FILE);
+  const previousBundleMeta = await fs28.pathExists(bundleMetaPath) ? await fs28.readFile(bundleMetaPath, "utf8") : null;
+  await writeJson(bundleMetaPath, meta);
+  try {
+    await fs28.ensureDir(path31.dirname(dest));
+    await tar.create({ gzip: true, cwd: cacheDir, file: dest }, ["."]);
+  } finally {
+    if (previousBundleMeta === null) await fs28.remove(bundleMetaPath);
+    else await fs28.writeFile(bundleMetaPath, previousBundleMeta, "utf8");
+  }
+}
+function isMarkdownFile(relOrAbsPath) {
+  return relOrAbsPath.toLowerCase().endsWith(".md");
+}
+async function listAllFilesUnfiltered(root, current = root) {
+  const entries = await fs28.readdir(current, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const abs = path31.join(current, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listAllFilesUnfiltered(root, abs));
+    } else if (entry.isFile()) {
+      out.push(path31.relative(root, abs).split(path31.sep).join("/"));
+    }
+  }
+  return out;
+}
+async function validateStagedItem(item, absPath) {
+  const stat = await fs28.stat(absPath).catch(() => null);
+  if (!stat) return { ok: true };
+  if (stat.isFile()) {
+    const content2 = await fs28.readFile(absPath, "utf8");
+    return validateCatalogItem(item, content2);
+  }
+  const files = await listAllFilesUnfiltered(absPath);
+  for (const rel of files) {
+    if (!isMarkdownFile(rel)) continue;
+    const content2 = await fs28.readFile(path31.join(absPath, rel), "utf8");
+    const verdict = validateCatalogItem(item, content2);
+    if (!verdict.ok) return verdict;
+  }
+  return { ok: true };
+}
+async function validateStagedItems(staging, items) {
+  let rejected = 0;
+  const accepted = [];
+  const contentlessIds = /* @__PURE__ */ new Set();
+  const coveredPaths = [];
+  for (const item of [...items, SUPERPOWERS_SHARED_ITEM]) {
+    const isSynthetic = item === SUPERPOWERS_SHARED_ITEM;
+    const contentPath = safeJoin(staging, item.path);
+    if (!contentPath) {
+      if (!isSynthetic) {
+        warn(`Refusing item with an unsafe path: ${item.id} (${item.path})`);
+        rejected += 1;
+      }
+      continue;
+    }
+    coveredPaths.push(item.path);
+    if (!await fs28.pathExists(contentPath)) {
+      if (!isSynthetic) {
+        accepted.push(item.id);
+        contentlessIds.add(item.id);
+      }
+      continue;
+    }
+    const verdict = await validateStagedItem(item, contentPath);
+    if (!verdict.ok) {
+      warn(`Rejected ${item.id}: ${verdict.reason}`);
+      await fs28.remove(contentPath);
+      if (!isSynthetic) rejected += 1;
+      continue;
+    }
+    if (!isSynthetic) accepted.push(item.id);
+  }
+  const stagedFiles = await listAllFilesUnfiltered(staging);
+  for (const rel of stagedFiles) {
+    if (rel === MANIFEST_FILE || rel === BUNDLE_META_FILE) continue;
+    const covered = coveredPaths.some((p) => rel === p || rel.startsWith(`${p}/`));
+    if (!covered) {
+      warn(`Refusing staged file outside any catalog item's path: ${rel}`);
+      await fs28.remove(path31.join(staging, rel));
+    }
+  }
+  await pruneEmptyDirs(staging);
+  return { accepted, rejected, contentlessIds };
+}
+async function pruneEmptyDirs(root, dir = root) {
+  const entries = await fs28.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      await pruneEmptyDirs(root, path31.join(dir, entry.name));
+    }
+  }
+  if (dir !== root && (await fs28.readdir(dir)).length === 0) {
+    await fs28.remove(dir);
+  }
+}
+async function stripSymlinks(dir) {
+  const removed = [];
+  const entries = await fs28.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const abs = path31.join(dir, entry.name);
+    if (entry.isSymbolicLink()) {
+      await fs28.remove(abs);
+      removed.push(abs);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      removed.push(...await stripSymlinks(abs));
+    }
+  }
+  return removed;
+}
+async function runBundleImport(file, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const archive = path31.resolve(file);
+  if (!await fs28.pathExists(archive)) {
+    error(`No such bundle: ${file}`);
+    process.exitCode = 1;
+    return;
+  }
+  const staging = await fs28.mkdtemp(path31.join(os2.tmpdir(), "haus-catalog-bundle-import-"));
+  try {
+    await tar.extract({
+      file: archive,
+      cwd: staging,
+      // Refuse anything that would land outside the staging dir. node-tar's own
+      // extraction already refuses `..`, absolute paths, and symlink escapes by
+      // default (preservePaths is left unset) — this filter is a second, independent
+      // check using the same path-safety module the network sync uses. Both this
+      // filter's refusals and node-tar's own built-in ones are logged — a tampered
+      // bundle's dropped entries must be visible, not silently absorbed.
+      filter: (entryPath) => {
+        const safe = isSafeCatalogPath(entryPath);
+        if (!safe) warn(`Refusing unsafe tar entry path: ${entryPath}`);
+        return safe;
+      },
+      onwarn: (code, message2) => warn(`tar: ${code}: ${message2}`)
+    });
+    const strippedSymlinks = await stripSymlinks(staging);
+    for (const abs of strippedSymlinks) {
+      warn(`Refusing symlink in bundle: ${path31.relative(staging, abs)}`);
+    }
+    const manifest = await readJson(path31.join(staging, MANIFEST_FILE));
+    if (!manifest?.items?.length) {
+      error("Bundle contains no catalog manifest \u2014 refusing to import.");
+      process.exitCode = 1;
+      return;
+    }
+    assertSupportedManifestFormat(manifest.manifestFormat, "The imported catalog bundle");
+    const { accepted, rejected, contentlessIds } = await validateStagedItems(
+      staging,
+      manifest.items
+    );
+    const meta = await readJson(path31.join(staging, BUNDLE_META_FILE));
+    const label = meta?.catalogRef ?? (meta?.version ? `v${meta.version}` : "unknown ref");
+    const installedCount = accepted.length;
+    if (dryRun) {
+      log(
+        dryRunPrefix(
+          true,
+          `would import ${installedCount} catalog item(s) from ${label} into ${getCacheDir()}`
+        )
+      );
+      accepted.forEach(
+        (id) => log(
+          dryRunPrefix(
+            true,
+            contentlessIds.has(id) ? `  ${id} (declared only, no content in bundle)` : `  ${id}`
+          )
+        )
+      );
+      if (rejected > 0) {
+        log(dryRunPrefix(true, `${rejected} item(s) would be rejected by validation (see above)`));
+      }
+      return;
+    }
+    await fs28.ensureDir(getCacheDir());
+    for (const entry of await fs28.readdir(staging)) {
+      await fs28.copy(path31.join(staging, entry), path31.join(getCacheDir(), entry), {
+        overwrite: true,
+        errorOnExist: false
+      });
+    }
+    log(
+      `Imported ${installedCount} catalog item(s) from ${label}.` + (rejected > 0 ? ` ${rejected} rejected by validation.` : "")
+    );
+    log("Run `haus apply --write` to install them.");
+  } catch (err) {
+    if (err instanceof UnsupportedManifestFormatError) {
+      error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  } finally {
+    await fs28.remove(staging);
+  }
 }
 
 // src/commands/doctor.ts
 import path45 from "node:path";
-import fs35 from "fs-extra";
+import fs37 from "fs-extra";
 init_manifest_format();
 
 // src/claude/former-install-orphans.ts
-import fs27 from "fs-extra";
+import fs29 from "fs-extra";
 init_path_safety();
 init_paths();
 var toPosix = (value) => value.replace(/\\/g, "/");
@@ -6060,7 +6440,7 @@ async function findOrphanedFormerInstalls(root, items, lockRows) {
     const projectRel = `.claude/${relPath}`;
     if (trackedPaths.has(projectRel) || reported.has(projectRel)) continue;
     const abs = safeJoin(claudePath(root), relPath);
-    if (abs === null || !await fs27.pathExists(abs)) continue;
+    if (abs === null || !await fs29.pathExists(abs)) continue;
     reported.add(projectRel);
     orphans.push({ formerId: entry.formerId, currentId: entry.currentId, relPath: projectRel });
   }
@@ -6071,7 +6451,7 @@ async function findOrphanedFormerInstalls(root, items, lockRows) {
 init_paths();
 import path32 from "node:path";
 import fg4 from "fast-glob";
-import fs28 from "fs-extra";
+import fs30 from "fs-extra";
 var REFERENCE_PATTERN = /\b([a-z][a-z0-9]*(?:-[a-z0-9]+)+):([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\b(?!:\/\/)/g;
 function stripFencedCodeBlocks(text) {
   return text.replace(/```[\s\S]*?```/g, (block) => block.replace(/[^\n]/g, " "));
@@ -6079,15 +6459,15 @@ function stripFencedCodeBlocks(text) {
 async function findUnresolvedSkillReferences(root, options = {}) {
   const resolvableNamespaces = new Set(options.pluginNamespaces ?? []);
   const skillsRoot = claudePath(root, "skills");
-  if (!await fs28.pathExists(skillsRoot)) return [];
-  const skillDirs = (await fs28.readdir(skillsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== "shared").map((entry) => entry.name);
+  if (!await fs30.pathExists(skillsRoot)) return [];
+  const skillDirs = (await fs30.readdir(skillsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== "shared").map((entry) => entry.name);
   const installedSkillNames = new Set(skillDirs);
   const files = await fg4("*/**/*.md", { cwd: skillsRoot, onlyFiles: true, dot: true });
   const issues = [];
   for (const rel of files) {
     if (rel.startsWith("shared/")) continue;
     const abs = path32.join(skillsRoot, rel);
-    const raw = await fs28.readFile(abs, "utf8");
+    const raw = await fs30.readFile(abs, "utf8");
     const lines = stripFencedCodeBlocks(raw).split("\n");
     lines.forEach((line2, idx) => {
       for (const match of line2.matchAll(REFERENCE_PATTERN)) {
@@ -6110,13 +6490,13 @@ async function findUnresolvedSkillReferences(root, options = {}) {
 // src/decisions/doctor.ts
 init_fs();
 import path37 from "node:path";
-import fs32 from "fs-extra";
+import fs34 from "fs-extra";
 
 // src/decisions/check.ts
 init_fs();
 init_paths();
 import path36 from "node:path";
-import fs31 from "fs-extra";
+import fs33 from "fs-extra";
 
 // src/decisions/dep-bump.ts
 var DEP_SECTIONS = [
@@ -6309,12 +6689,12 @@ function firstMatchingRegex(filePath, patterns) {
 
 // src/decisions/paths.ts
 import path34 from "node:path";
-import fs29 from "fs-extra";
+import fs31 from "fs-extra";
 async function resolveDecisionsDir(root) {
   const primary = path34.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  if (await fs29.pathExists(primary)) return primary;
+  if (await fs31.pathExists(primary)) return primary;
   const legacy = path34.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  if (await fs29.pathExists(legacy)) return legacy;
+  if (await fs31.pathExists(legacy)) return legacy;
   return primary;
 }
 function relativeDecisionPath(decisionsDir, root) {
@@ -6324,7 +6704,7 @@ function relativeDecisionPath(decisionsDir, root) {
 // src/decisions/validate.ts
 init_fs();
 import path35 from "node:path";
-import fs30 from "fs-extra";
+import fs32 from "fs-extra";
 function validateDecisionContent(content2) {
   const errors = [];
   for (const section of DECISIONS_TRIGGERS.requiredSections) {
@@ -6354,7 +6734,7 @@ function decisionNumberFromFile(name) {
 }
 async function validateIndexSync(decisionsDir, decisionFiles) {
   const readmePath = path35.join(decisionsDir, "README.md");
-  if (!await fs30.pathExists(readmePath)) {
+  if (!await fs32.pathExists(readmePath)) {
     return ["docs/decisions/README.md is missing"];
   }
   const readme = await readText(readmePath) ?? "";
@@ -6526,8 +6906,8 @@ ${opts.commitMessages ?? ""}`;
     changedFiles: stats.files
   });
   if (satisfactionErrors.length > 0 && decisionsRel !== legacyRel) {
-    const legacyExists = await fs31.pathExists(path36.join(root, legacyRel));
-    if (legacyExists && !await fs31.pathExists(decisionsDir)) {
+    const legacyExists = await fs33.pathExists(path36.join(root, legacyRel));
+    if (legacyExists && !await fs33.pathExists(decisionsDir)) {
       satisfactionErrors = await checkSatisfaction({
         root,
         decisionsRel: legacyRel,
@@ -6549,8 +6929,8 @@ ${opts.commitMessages ?? ""}`;
   return { triggered: true, satisfied: false, reasons, securityTriggered };
 }
 async function listDecisionNumbers(decisionsDir) {
-  if (!await fs31.pathExists(decisionsDir)) return [];
-  const entries = await fs31.readdir(decisionsDir);
+  if (!await fs33.pathExists(decisionsDir)) return [];
+  const entries = await fs33.readdir(decisionsDir);
   return entries.map((name) => decisionNumberFromFile(name)).filter((n) => n != null).map((n) => Number(n));
 }
 
@@ -6559,8 +6939,8 @@ async function auditDecisionsLayout(root) {
   const findings = [];
   const primary = path37.join(root, DECISIONS_TRIGGERS.decisionsDir);
   const legacy = path37.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  const hasPrimary = await fs32.pathExists(primary);
-  const hasLegacy = await fs32.pathExists(legacy);
+  const hasPrimary = await fs34.pathExists(primary);
+  const hasLegacy = await fs34.pathExists(legacy);
   if (!hasPrimary && hasLegacy) {
     findings.push({
       level: "advisory",
@@ -6574,7 +6954,7 @@ async function auditDecisionsLayout(root) {
   const decisionsDir = await resolveDecisionsDir(root);
   const rel = relativeDecisionPath(decisionsDir, root);
   const readmePath = path37.join(decisionsDir, "README.md");
-  if (!await fs32.pathExists(readmePath)) {
+  if (!await fs34.pathExists(readmePath)) {
     findings.push({
       level: "advisory",
       line: `- DECISIONS: missing ${rel}/README.md index`,
@@ -6584,7 +6964,7 @@ async function auditDecisionsLayout(root) {
     return findings;
   }
   const readme = await readText(readmePath);
-  const entries = (await fs32.readdir(decisionsDir)).filter(
+  const entries = (await fs34.readdir(decisionsDir)).filter(
     (f) => f.endsWith(".md") && f !== "README.md"
   );
   for (const file of entries) {
@@ -6633,7 +7013,7 @@ init_fs();
 init_logger();
 init_paths();
 import path38 from "node:path";
-import fs33 from "fs-extra";
+import fs35 from "fs-extra";
 function manifestPathIn(configDir) {
   return path38.join(configDir, "haus", "install-manifest.json");
 }
@@ -6663,9 +7043,9 @@ async function pruneVacatedDirs(root, vacatedFiles) {
 async function destinationWritable(dir) {
   let candidate = path38.resolve(dir);
   for (; ; ) {
-    if (await fs33.pathExists(candidate)) {
+    if (await fs35.pathExists(candidate)) {
       try {
-        await fs33.access(candidate, fs33.constants.W_OK);
+        await fs35.access(candidate, fs35.constants.W_OK);
         return true;
       } catch (err) {
         return err instanceof Error ? err.message : String(err);
@@ -6697,7 +7077,7 @@ async function migrateGlobalConfigDir(options = {}) {
   if (!legacy || !Array.isArray(legacy.files)) {
     return { ...base, reason: "no install manifest under ~/.claude" };
   }
-  if (await fs33.pathExists(manifestPathIn(to))) {
+  if (await fs35.pathExists(manifestPathIn(to))) {
     return { ...base, reason: "an install manifest already exists in the resolved config dir" };
   }
   const writable = await destinationWritable(to);
@@ -6720,14 +7100,14 @@ async function migrateGlobalConfigDir(options = {}) {
       continue;
     }
     const newDest = path38.join(to, rel);
-    if (!await fs33.pathExists(entry.destPath)) {
+    if (!await fs35.pathExists(entry.destPath)) {
       rewritten.push({ ...entry, destPath: newDest });
       continue;
     }
-    if (await fs33.pathExists(newDest)) {
+    if (await fs35.pathExists(newDest)) {
       if (await sameContent(entry.destPath, newDest)) {
         if (!dryRun) {
-          await fs33.remove(entry.destPath);
+          await fs35.remove(entry.destPath);
           vacated.push(entry.destPath);
         }
         moved.push(newDest);
@@ -6744,7 +7124,7 @@ async function migrateGlobalConfigDir(options = {}) {
       continue;
     }
     try {
-      await fs33.move(entry.destPath, newDest);
+      await fs35.move(entry.destPath, newDest);
       vacated.push(entry.destPath);
       moved.push(newDest);
       rewritten.push({ ...entry, destPath: newDest });
@@ -6769,7 +7149,7 @@ async function migrateGlobalConfigDir(options = {}) {
   }
   try {
     await writeJson(manifestPathIn(to), { ...legacy, files: rewritten });
-    await fs33.remove(legacyManifestPath);
+    await fs35.remove(legacyManifestPath);
     vacated.push(legacyManifestPath);
   } catch (err) {
     return {
@@ -6815,7 +7195,7 @@ function printConfigDirMigration(result) {
 
 // src/scanner/read-context.ts
 import path44 from "node:path";
-import fs34 from "fs-extra";
+import fs36 from "fs-extra";
 
 // src/commands/workspace/config.ts
 init_fs();
@@ -7399,10 +7779,10 @@ async function isCacheFresh(root, cachePath) {
     path44.join(root, WORKSPACE_FILE),
     path44.join(root, REPOS_MANIFEST_FILE)
   ];
-  const cacheStat = await fs34.stat(cachePath);
+  const cacheStat = await fs36.stat(cachePath);
   for (const markerPath of markerPaths) {
-    if (!await fs34.pathExists(markerPath)) continue;
-    const markerStat = await fs34.stat(markerPath);
+    if (!await fs36.pathExists(markerPath)) continue;
+    const markerStat = await fs36.stat(markerPath);
     if (markerStat.mtimeMs > cacheStat.mtimeMs) return false;
   }
   return true;
@@ -7416,11 +7796,15 @@ async function readContextOrScan(root) {
 }
 
 // src/update/npm-version.ts
+init_offline();
 var NPM_PACKAGE_NAME = "@haus-tech/haus-workflow";
 function isTestMode2() {
   return process.env["HAUS_TEST_MODE"] === "1" || process.env["NODE_ENV"] === "test";
 }
 async function fetchNpmVersionStatus(currentVersion) {
+  if (isOffline()) {
+    return { current: currentVersion, latest: null, updateAvailable: false };
+  }
   if (isTestMode2() && process.env["HAUS_SKIP_NPM_CHECK"]) {
     return { current: currentVersion, latest: null, updateAvailable: false };
   }
@@ -7559,7 +7943,7 @@ async function runDoctor(options) {
         const resolved = path45.resolve(root, target);
         const relFromRoot = path45.relative(root, resolved);
         const escapesRoot = relFromRoot === ".." || relFromRoot.startsWith(`..${path45.sep}`) || path45.isAbsolute(relFromRoot);
-        if (escapesRoot || !await fs35.pathExists(resolved)) {
+        if (escapesRoot || !await fs37.pathExists(resolved)) {
           flag(
             `- CLAUDE.md import: @${target} does not resolve (run \`haus apply --write\`)`,
             `A file CLAUDE.md links to (${target}) is missing, so part of the guidance won't load`,
@@ -7577,7 +7961,7 @@ async function runDoctor(options) {
     );
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs35.pathExists(workflowPath);
+  const workflowExists = await fs37.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -7600,7 +7984,7 @@ async function runDoctor(options) {
         "templates",
         "agentic-workflow-standard.md"
       );
-      const templatePath = await fs35.pathExists(cachePath) ? cachePath : bundledPath;
+      const templatePath = await fs37.pathExists(cachePath) ? cachePath : bundledPath;
       const templateContent = await readText(templatePath);
       const verdict = checkManagedTamper(bodyContent, storedHashMatch?.[1], templateContent ?? null);
       if (verdict.status === "tampered" || verdict.status === "legacy-diverged") {
@@ -7628,7 +8012,7 @@ async function runDoctor(options) {
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs35.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs37.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -7636,7 +8020,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs35.readFile(workflowConfigPath, "utf8");
+    const cfg = await fs37.readFile(workflowConfigPath, "utf8");
     const unfilled = cfg.split("\n").filter((l) => l.includes("<!-- fill in")).length;
     if (unfilled > 0) {
       suggest(
@@ -7665,12 +8049,12 @@ async function runDoctor(options) {
   const trackedArtifacts = await listTrackedArtifactPaths(root);
   if (trackedArtifacts.length > 0) {
     flag(
-      `- GITIGNORE: ${trackedArtifacts.length} machine-local scan artifact(s) still tracked in git (${trackedArtifacts.join(", ")})`,
-      `${trackedArtifacts.length} machine-local scan artifact(s) are still tracked in git`,
+      `- GITIGNORE: ${trackedArtifacts.length} machine-local artifact(s) still tracked in git (${trackedArtifacts.join(", ")})`,
+      `${trackedArtifacts.length} machine-local artifact(s) are still tracked in git`,
       `git rm --cached ${trackedArtifacts.join(" ")} (or run \`haus apply --write\` to do this and update .gitignore for you)`
     );
   } else {
-    ok("- GITIGNORE: OK (no machine-local scan artifacts tracked in git)");
+    ok("- GITIGNORE: OK (no machine-local artifacts tracked in git)");
   }
   const gitignoredHausPaths = await findGitignoredHausPaths(root);
   if (gitignoredHausPaths.length > 0) {
@@ -7690,8 +8074,10 @@ async function runDoctor(options) {
     else suggest(finding.line, finding.sentence, finding.fix);
   }
   let catalogItems = null;
+  let catalogCtx = null;
   try {
-    catalogItems = await loadCatalog(root);
+    catalogCtx = await loadCatalogContext(root);
+    catalogItems = catalogCtx.items;
   } catch (err) {
     if (!(err instanceof UnsupportedManifestFormatError)) throw err;
     flag(
@@ -7784,6 +8170,31 @@ async function runDoctor(options) {
       );
     }
   }
+  let catalogTier;
+  let catalogVersion;
+  let installableItems;
+  if (catalogCtx !== null) {
+    const { installable } = await countInstallableItems(catalogCtx);
+    catalogTier = catalogCtx.source;
+    catalogVersion = catalogCtx.version;
+    installableItems = installable;
+    const tierLabel = `${catalogTier}${catalogVersion ? ` (v${catalogVersion})` : ""}`;
+    if (catalogTier === "bundled") {
+      suggest(
+        `- CATALOG TIER: ${tierLabel} \u2014 frozen at publish time, metadata only (${installableItems} installable item(s))`,
+        `Catalog is being served from the snapshot bundled with this CLI (${tierLabel}), frozen at publish time and carrying metadata only \u2014 ${installableItems} of its items have installable content, so \`haus apply\` will write core files only`,
+        "haus update (with network access), or `haus catalog bundle import` on a disconnected machine"
+      );
+    } else if (installableItems === 0) {
+      suggest(
+        `- CATALOG TIER: ${tierLabel} \u2014 0 installable items (\`haus apply\` will write core files only)`,
+        `The ${catalogTier} catalog tier has 0 installable items`,
+        "haus update (or `haus catalog bundle import` on a disconnected machine)"
+      );
+    } else {
+      ok(`- CATALOG TIER: ${tierLabel} \u2014 ${installableItems} installable item(s)`);
+    }
+  }
   const cacheAgeMs = await getCacheManifestAge();
   if (cacheAgeMs === null) {
     suggest(
@@ -7877,7 +8288,7 @@ async function runDoctor(options) {
       let onDisk = false;
       for (const rel of row.paths ?? []) {
         const abs = resolveContainedPath(root, rel);
-        if (abs !== null && await fs35.pathExists(abs)) {
+        if (abs !== null && await fs37.pathExists(abs)) {
           onDisk = true;
           break;
         }
@@ -7909,7 +8320,21 @@ async function runDoctor(options) {
   }
   if (attention.length > 0) process.exitCode = 1;
   if (options?.json) {
-    log(JSON.stringify({ ok: attention.length === 0, attention, suggestions, detail }, null, 2));
+    log(
+      JSON.stringify(
+        {
+          ok: attention.length === 0,
+          attention,
+          suggestions,
+          detail,
+          catalogTier,
+          catalogVersion,
+          installableItems
+        },
+        null,
+        2
+      )
+    );
     return;
   }
   if (attention.length === 0) {
@@ -7934,11 +8359,11 @@ import path48 from "node:path";
 init_github_rate_limit();
 
 // src/claude/refresh-project.ts
-import fs36 from "fs-extra";
+import fs38 from "fs-extra";
 init_fs();
 init_paths();
 async function isHausProject(root) {
-  if (await fs36.pathExists(hausPath(root, "recommendation.json"))) return true;
+  if (await fs38.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;
@@ -7955,7 +8380,7 @@ async function refreshProjectApply(root) {
 // src/install/apply.ts
 import crypto2 from "node:crypto";
 import path46 from "node:path";
-import fs37 from "fs-extra";
+import fs39 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -8044,7 +8469,7 @@ function hashContent(content2) {
 }
 function destFileMissing(destPath) {
   try {
-    return !fs37.statSync(destPath).isFile();
+    return !fs39.statSync(destPath).isFile();
   } catch {
     return true;
   }
@@ -8052,7 +8477,7 @@ function destFileMissing(destPath) {
 function sourceVersion() {
   try {
     const pkgPath = path46.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs37.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs39.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
@@ -8064,10 +8489,10 @@ function globalSrcDir() {
 function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
   const skillDir = path46.join(skillsDir, skillName);
   const entries = [];
-  for (const rel of fs37.readdirSync(skillDir, { recursive: true })) {
+  for (const rel of fs39.readdirSync(skillDir, { recursive: true })) {
     if (rel === "SKILL.md") continue;
     const abs = path46.join(skillDir, rel);
-    if (!fs37.statSync(abs).isFile()) continue;
+    if (!fs39.statSync(abs).isFile()) continue;
     const posixRel = rel.split(path46.sep).join("/");
     entries.push({
       stableId: `skill.${skillName}.${posixRel.replace(/\//g, ".")}`,
@@ -8080,10 +8505,10 @@ function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
   const skillsDir = path46.join(srcDir, "skills");
-  if (fs37.pathExistsSync(skillsDir)) {
-    for (const skillName of fs37.readdirSync(skillsDir)) {
+  if (fs39.pathExistsSync(skillsDir)) {
+    for (const skillName of fs39.readdirSync(skillsDir)) {
       const skillFile = path46.join(skillsDir, skillName, "SKILL.md");
-      if (fs37.pathExistsSync(skillFile)) {
+      if (fs39.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
           srcRelPath: path46.join("library", "global", "skills", skillName, "SKILL.md"),
@@ -8094,8 +8519,8 @@ function collectSourceFiles(srcDir, claudeDir) {
     }
   }
   const commandsDir = path46.join(srcDir, "commands");
-  if (fs37.pathExistsSync(commandsDir)) {
-    for (const fileName of fs37.readdirSync(commandsDir)) {
+  if (fs39.pathExistsSync(commandsDir)) {
+    for (const fileName of fs39.readdirSync(commandsDir)) {
       if (!fileName.endsWith(".md")) continue;
       const commandName = fileName.slice(0, -".md".length);
       entries.push({
@@ -8154,7 +8579,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs37.pathExistsSync(entry.destPath);
+    const destExists = fs39.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -8213,13 +8638,13 @@ async function applyInstall(options = {}) {
         manifestFiles.push(entry);
         continue;
       }
-      if (!fs37.pathExistsSync(entry.destPath)) continue;
+      if (!fs39.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 fs37.remove(entry.destPath);
+        if (!dryRun) await fs39.remove(entry.destPath);
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -8291,7 +8716,8 @@ function summarizeLockDiff(before, after) {
 }
 
 // src/update/lockfile.ts
-import { mkdir, readFile as readFile2, copyFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { copyFile, mkdir, readFile as readFile2 } from "node:fs/promises";
 import path47 from "node:path";
 init_fs();
 init_paths();
@@ -8325,16 +8751,30 @@ async function readLockRaw(root) {
     return "[]";
   }
 }
-async function applyLock(root) {
+async function backupLockfile(root) {
   const lockPath = hausPath(root, "haus.lock.json");
-  const before = await readLockRaw(root);
-  const lock = await readJson(lockPath) ?? [];
   try {
     const backupDir = hausPath(root, "backups");
     await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path47.join(backupDir, `haus.lock.${Date.now()}.json`));
+    let stamp = Date.now();
+    for (; ; ) {
+      const dest = path47.join(backupDir, lockBackupFileName(stamp));
+      try {
+        await copyFile(lockPath, dest, fsConstants.COPYFILE_EXCL);
+        return;
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        stamp += 1;
+      }
+    }
   } catch {
   }
+}
+async function applyLock(root) {
+  const lockPath = hausPath(root, "haus.lock.json");
+  const before = await readLockRaw(root);
+  const lock = await readJson(lockPath) ?? [];
+  await backupLockfile(root);
   const enriched = await Promise.all(
     lock.map(async (x) => {
       const paths = Array.isArray(x.paths) ? x.paths.map(String) : [];
@@ -8357,12 +8797,7 @@ async function removeLockEntries(root, ids) {
   const removed = [...wanted].filter((id) => present.has(id));
   const missing = [...wanted].filter((id) => !present.has(id));
   if (removed.length === 0) return { removed, missing, before, after: before };
-  try {
-    const backupDir = hausPath(root, "backups");
-    await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path47.join(backupDir, `haus.lock.${Date.now()}.json`));
-  } catch {
-  }
+  await backupLockfile(root);
   const survivors = lock.filter((item) => !wanted.has(item.id));
   await writeJson(lockPath, survivors);
   return { removed, missing, before, after: `${JSON.stringify(survivors, null, 2)}
@@ -8804,7 +9239,7 @@ async function runClone(url, opts = {}) {
 // src/install/scaffold.ts
 init_logger();
 import path50 from "node:path";
-import fs38 from "fs-extra";
+import fs40 from "fs-extra";
 async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   const scaffolded = [];
   const skipped = [];
@@ -8817,7 +9252,7 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
     skipped.push(name);
     if (outcome === "skipped-exists") skippedExisting.push(name);
   };
-  const realRoot = await fs38.realpath(catalogRoot).catch(() => null);
+  const realRoot = await fs40.realpath(catalogRoot).catch(() => null);
   for (const item of items) {
     if (item.type !== "config") continue;
     const sourcePath = path50.resolve(catalogRoot, item.path);
@@ -8827,7 +9262,7 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       warn(`Skipping ${item.id}: path '${item.path}' escapes the catalog root`);
       continue;
     }
-    const realSource = await fs38.realpath(sourcePath).catch(() => null);
+    const realSource = await fs40.realpath(sourcePath).catch(() => null);
     if (!realRoot || !realSource) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -8837,7 +9272,7 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       warn(`Skipping ${item.id}: path '${item.path}' resolves outside the catalog root`);
       continue;
     }
-    const stat = await fs38.lstat(sourcePath).catch(() => null);
+    const stat = await fs40.lstat(sourcePath).catch(() => null);
     if (!stat) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -8851,7 +9286,7 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       const dest = path50.join(projectRoot, filename);
       record(filename, await scaffoldFile(sourcePath, dest, item.id, projectRoot, opts));
     } else if (stat.isDirectory()) {
-      const entries = await fs38.readdir(sourcePath);
+      const entries = await fs40.readdir(sourcePath);
       for (const entry of entries) {
         const src = path50.join(sourcePath, entry);
         const dest = path50.join(projectRoot, entry);
@@ -8863,7 +9298,7 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
 }
 async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
   const destDisplay = path50.relative(projectRoot, dest) || path50.basename(dest);
-  const srcStat = await fs38.lstat(src).catch(() => null);
+  const srcStat = await fs40.lstat(src).catch(() => null);
   if (!srcStat) {
     warn(`Skipping ${path50.basename(src)}: source not found`);
     return "skipped-refused";
@@ -8872,7 +9307,7 @@ async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
     warn(`Skipping ${path50.basename(src)}: source is a symlink`);
     return "skipped-refused";
   }
-  const exists = await fs38.pathExists(dest);
+  const exists = await fs40.pathExists(dest);
   if (exists && !opts.force) {
     warn(`Skipping ${destDisplay}: already exists \u2014 re-run with --force to overwrite it`);
     return "skipped-exists";
@@ -8882,16 +9317,16 @@ async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
     return "scaffolded";
   }
   if (exists && opts.force) {
-    await fs38.remove(dest);
+    await fs40.remove(dest);
   }
-  await fs38.ensureDir(path50.dirname(dest));
-  await fs38.copy(src, dest, {
+  await fs40.ensureDir(path50.dirname(dest));
+  await fs40.copy(src, dest, {
     overwrite: true,
     dereference: false,
     // A vanished/unreadable entry mid-walk must skip that path, not crash the copy.
     filter: (s) => {
       try {
-        return !fs38.lstatSync(s).isSymbolicLink();
+        return !fs40.lstatSync(s).isSymbolicLink();
       } catch {
         return false;
       }
@@ -9413,6 +9848,61 @@ async function runGuard(kind, _options) {
 // src/claude/setup-core.ts
 init_github_rate_limit();
 
+// src/claude/project-exclusions.ts
+import fs41 from "fs-extra";
+init_project_pin();
+init_fs();
+init_logger();
+init_paths();
+function normalizeExcludedIds(value) {
+  if (!Array.isArray(value)) return [];
+  return [
+    ...new Set(
+      value.filter((entry) => typeof entry === "string" && entry.length > 0)
+    )
+  ];
+}
+async function readProjectExcludedIds(root) {
+  try {
+    const data = await readJson(hausPath(root, PROJECT_CONFIG_FILE));
+    if (!data) return [];
+    return normalizeExcludedIds(data.excludedIds);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    warn(
+      `${PROJECT_CONFIG_REL} could not be read for excludedIds (${err instanceof Error ? err.message : String(err)}) \u2014 treating as none`
+    );
+    return [];
+  }
+}
+function isItemExcluded(item, excluded) {
+  if (excluded.has(item.id)) return true;
+  return normalizeFormerIds(item.formerIds).some((formerId) => excluded.has(formerId));
+}
+async function addProjectExcludedIds(root, ids) {
+  const toAdd = [...new Set(ids.filter((id) => id.length > 0))];
+  if (toAdd.length === 0) return;
+  const file = hausPath(root, PROJECT_CONFIG_FILE);
+  let existing = {};
+  if (await fs41.pathExists(file)) {
+    try {
+      const parsed = JSON.parse(await fs41.readFile(file, "utf8"));
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        existing = { ...parsed };
+      } else {
+        warn(`${PROJECT_CONFIG_REL} is not a JSON object \u2014 rewriting with excludedIds only`);
+      }
+    } catch (err) {
+      warn(
+        `${PROJECT_CONFIG_REL} could not be parsed (${err instanceof Error ? err.message : String(err)}) \u2014 rewriting with excludedIds only`
+      );
+    }
+  }
+  const merged = normalizeExcludedIds(existing.excludedIds);
+  const next = [.../* @__PURE__ */ new Set([...merged, ...toAdd])].sort();
+  await writeJson(file, { ...existing, excludedIds: next });
+}
+
 // src/recommender/recommend.ts
 init_fs();
 init_paths();
@@ -9459,6 +9949,7 @@ async function readChangedFiles(root) {
 async function recommend(root, context, opts = {}) {
   const activePluginIds = opts.activePluginIds ?? [];
   const items = await loadCatalog(root);
+  const excludedIds = await readProjectExcludedIds(root);
   const sources = buildSourcesReport(items);
   const deep = await readJson(hausPath(root, "deep-context.json")) ?? {};
   const scannerStacks = buildStackSet(context);
@@ -9668,6 +10159,7 @@ async function recommend(root, context, opts = {}) {
     }
   }
   applyCoInstallSuppression(recommended, skipped);
+  applyManualExcludes(excludedIds, items, recommended, skipped);
   const includeWarnings = applyManualIncludes(opts.include ?? [], items, recommended, skipped);
   const optInEligible = buildOptInEligible(items, skipped);
   recommended.sort((a, b) => a.id.localeCompare(b.id));
@@ -9696,6 +10188,29 @@ function buildStackSet(context) {
     )
   );
 }
+function applyManualExcludes(excludedIds, items, recommended, skipped) {
+  if (excludedIds.length === 0) return;
+  const excluded = new Set(excludedIds);
+  const byId = new Map(items.map((item) => [item.id, item]));
+  for (let i = recommended.length - 1; i >= 0; i--) {
+    const entry = recommended[i];
+    const item = byId.get(entry.id);
+    if (!item || !isItemExcluded(item, excluded)) continue;
+    recommended.splice(i, 1);
+    skipped.push({
+      id: entry.id,
+      reason: "manually excluded",
+      skipReasons: [
+        {
+          code: "manual-exclude",
+          message: "manually excluded via haus remove",
+          signal: "selection:manual-exclude"
+        }
+      ],
+      ...entry.gates ? { gates: entry.gates } : {}
+    });
+  }
+}
 function applyCoInstallSuppression(recommended, skipped) {
   const recommendedIds = new Set(recommended.map((r) => r.id));
   const rules = [
@@ -10068,7 +10583,10 @@ async function runSetupCore(root, opts) {
       recommendedCount: 0,
       warnings,
       hooksOk: false,
-      written: []
+      written: [],
+      // Pre-existing zero-signal guard, not the #325 catalog-install honesty check —
+      // deliberately left out of scope for `catalogInstallOk` (see its doc comment).
+      catalogInstallOk: true
     };
   }
   await writeJson(hausPath(root, "recommendation.json"), recommendation);
@@ -10097,7 +10615,8 @@ async function runSetupCore(root, opts) {
     recommendedCount: recommendation.recommended.length,
     warnings: warningLines,
     hooksOk,
-    written: []
+    written: [],
+    catalogInstallOk: true
   };
   const envelope = (hooksResult) => ({
     scan: scanResult,
@@ -10137,12 +10656,66 @@ async function runSetupCore(root, opts) {
       warn(formatGithubRateLimitMessage(sync.rateLimit));
     }
   }
+  const isPreview = dryRun ?? false;
+  const wantedIds = installableRecommendedItems(recommendation.recommended).map((item) => item.id);
+  let catalogCtx = null;
+  let resolvedWantedIds = wantedIds;
+  if (wantedIds.length > 0) {
+    catalogCtx = await loadCatalogContext(root);
+    const prevLock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
+    const migrations = findFormerIdMigrations(
+      prevLock.filter((entry) => Boolean(entry.id)),
+      catalogCtx.items
+    );
+    const migrationByOldId = new Map(migrations.map((m) => [m.oldId, m.newId]));
+    resolvedWantedIds = wantedIds.map((id) => migrationByOldId.get(id) ?? id);
+    const shortfall = await countInstallableItems(catalogCtx, resolvedWantedIds);
+    const tier = `${catalogCtx.source}${catalogCtx.version ? ` (v${catalogCtx.version})` : ""}`;
+    if (shortfall.installable === 0) {
+      const message2 = "No catalog content found. Run `haus update` first.";
+      if (!opts.allowEmptyCache) {
+        if (isPreview) {
+          warn(`Catalog cache is empty \u2014 dry-run will skip catalog items. ${message2}`);
+        } else {
+          error(message2);
+          process.exitCode = 1;
+          emitJsonEnvelope(json, quiet, envelope(hooks));
+          return { ...baseResult, catalogInstallOk: false };
+        }
+      } else {
+        warn(
+          `Serving catalog metadata from the ${tier} tier, which has no installable content. Core files will be written; all ${wantedIds.length} catalog item(s) will be skipped.`
+        );
+      }
+    } else if (shortfall.missing.length > 0) {
+      warn(
+        `The ${tier} catalog tier is missing content for ${shortfall.missing.length} item(s): ${shortfall.missing.join(", ")}. They will be skipped.`
+      );
+    }
+  }
   const files = await writeClaudeFiles(root, dryRun ?? false, void 0, {
     quiet: opts.quiet,
     activePluginIds
   });
   say("Applied files:");
   files.forEach((f) => say(`- ${displayPath(root, f)}`));
+  let catalogInstallOk = true;
+  if (!isPreview && resolvedWantedIds.length > 0) {
+    const { installedCount: installedWantedCount, missingWantedIds } = await recountInstalledAgainstLock(root, resolvedWantedIds);
+    if (missingWantedIds.length > 0) {
+      const tier = catalogCtx ? `${catalogCtx.source}${catalogCtx.version ? ` (v${catalogCtx.version})` : ""}` : "unknown";
+      say(
+        `${installedWantedCount} of ${resolvedWantedIds.length} catalog items installed (${tier} tier).`
+      );
+      if (installedWantedCount === 0) {
+        error(
+          "No catalog items were installed \u2014 only core files were written. Run `haus update` with network access, or import a catalog bundle."
+        );
+        process.exitCode = 1;
+        catalogInstallOk = false;
+      }
+    }
+  }
   const hooksAfter = await verifyProjectSettingsHooksContract(root);
   const hooksOkAfter = hooksAfter.ok;
   if (hooksAfter.skipped) {
@@ -10154,7 +10727,7 @@ async function runSetupCore(root, opts) {
     say(`- HOOKS OK: ${hooksAfter.message}`);
   }
   emitJsonEnvelope(json, quiet, envelope(hooksAfter));
-  return { ...baseResult, hooksOk: hooksOkAfter, written: files };
+  return { ...baseResult, hooksOk: hooksOkAfter, written: files, catalogInstallOk };
 }
 
 // src/commands/init.ts
@@ -10174,6 +10747,7 @@ async function runInit(options) {
     apply: !dryRun,
     dryRun: false,
     force: options.force,
+    allowEmptyCache: options.allowEmptyCache,
     confirm: () => confirm("Approve and write Claude files now?")
   });
 }
@@ -10304,7 +10878,7 @@ async function runInstall(options, deps = {}) {
 
 // src/new-project/create-project.ts
 import path53 from "node:path";
-import fs39 from "fs-extra";
+import fs42 from "fs-extra";
 init_exec();
 init_logger();
 
@@ -10458,7 +11032,7 @@ async function createProject(opts, deps = defaultDeps) {
       `Invalid project name "${opts.name}" (lowercase letters, digits, . _ - only).`
     );
   }
-  if (await fs39.pathExists(projectPath)) {
+  if (await fs42.pathExists(projectPath)) {
     return fail("preflight", `Target ${projectPath} already exists \u2014 refusing to write into it.`);
   }
   const scaffoldArgs = stack.scaffold.args.map(
@@ -10536,15 +11110,15 @@ async function createProject(opts, deps = defaultDeps) {
     steps.push({ step: "scaffold", status: "done" });
     phase = "git";
     if (!opts.json) log("\u25B6 git: init/branch/commit");
-    if (!await fs39.pathExists(path53.join(projectPath, ".git"))) {
+    if (!await fs42.pathExists(path53.join(projectPath, ".git"))) {
       const init = await deps.git(["init"], { cwd: projectPath });
       if (init.exitCode !== 0) return fail("git", `git init failed: ${init.stderr}`);
     }
     const branch = await deps.git(["branch", "-M", "main"], { cwd: projectPath });
     if (branch.exitCode !== 0) return fail("git", `git branch -M main failed: ${branch.stderr}`);
     const lockfile = opts.pm === "yarn" ? "yarn.lock" : opts.pm === "pnpm" ? "pnpm-lock.yaml" : "package-lock.json";
-    if (!await fs39.pathExists(path53.join(projectPath, lockfile))) {
-      await fs39.writeFile(path53.join(projectPath, lockfile), "");
+    if (!await fs42.pathExists(path53.join(projectPath, lockfile))) {
+      await fs42.writeFile(path53.join(projectPath, lockfile), "");
     }
     const add = await deps.git(["add", "-A"], { cwd: projectPath });
     if (add.exitCode !== 0) return fail("git", `git add failed: ${add.stderr}`);
@@ -10799,6 +11373,7 @@ async function runRecommend(options) {
 }
 
 // src/commands/remove.ts
+import path54 from "node:path";
 init_fs();
 init_logger();
 init_paths();
@@ -10810,7 +11385,7 @@ async function runRemove(ids, options = {}) {
   const dryRun = Boolean(options.dryRun);
   const say = options.json ? () => {
   } : log;
-  const wanted = parseIdList(ids);
+  const wanted = [...new Set(parseIdList(ids))];
   if (wanted.length === 0) {
     error("Specify at least one catalog item id \u2014 see `haus doctor` for what is installed.");
     process.exitCode = 1;
@@ -10856,7 +11431,7 @@ async function runRemove(ids, options = {}) {
       cleared.push({ id, existing: [] });
       continue;
     }
-    const gate = await hashGateEntry(root, { id, hash: entry.hash }, existing);
+    const gate = await hashGateEntry(root, { hash: entry.hash }, existing);
     if (!gate.ok) {
       const detail = gate.reason === "no-hash" ? "has no lock hash" : "was modified locally";
       warn(
@@ -10902,7 +11477,8 @@ async function runRemove(ids, options = {}) {
     }
   }
   const allAbs = cleared.flatMap(({ existing }) => existing.map(({ abs }) => abs));
-  report.backupDir = await backupTrackedPaths(root, allAbs, say, "remove");
+  const backupRoot = await backupTrackedPaths(root, allAbs, say, "remove");
+  report.backupDir = backupRoot === null ? null : path54.basename(backupRoot);
   for (const { id, existing } of cleared) {
     await deleteTrackedPaths(root, id, existing, { verb: "Removed", reason: "" }, say);
   }
@@ -10910,6 +11486,10 @@ async function runRemove(ids, options = {}) {
     root,
     cleared.map((c) => c.id)
   );
+  await addProjectExcludedIds(
+    root,
+    cleared.map((c) => c.id)
+  );
   try {
     const remaining = await readJson(hausPath(root, "haus.lock.json")) ?? [];
     const remainingIds = new Set(remaining.map((e) => e.id));
@@ -10925,7 +11505,6 @@ async function runRemove(ids, options = {}) {
   }
   if (!options.json) {
     log(`Removed ${report.removed.length} item(s). Restore with \`haus backups list\`.`);
-    log("Note: a later `haus apply --write` reinstalls any of these still recommended.");
   }
   emitReport(report, options.json);
 }
@@ -10987,8 +11566,8 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path54 from "node:path";
-import fs40 from "fs-extra";
+import path55 from "node:path";
+import fs43 from "fs-extra";
 
 // src/claude/managed-paths.ts
 init_paths();
@@ -11007,7 +11586,7 @@ init_paths();
 async function collectCoreManagedPaths(root) {
   const existing = [];
   for (const abs of coreManagedAbsolutePaths(root)) {
-    if (await fs40.pathExists(abs)) existing.push(abs);
+    if (await fs43.pathExists(abs)) existing.push(abs);
   }
   return existing;
 }
@@ -11016,108 +11595,101 @@ async function collectLockTrackedPaths(root) {
   const removable = [];
   const preserved = [];
   for (const row of lock ?? []) {
-    const relPaths = row.paths ?? [];
-    const existingRel = [];
-    for (const rel of relPaths) {
-      if (await fs40.pathExists(path54.resolve(root, rel))) existingRel.push(rel);
-    }
-    if (existingRel.length === 0) continue;
-    if (row.hash === void 0) {
-      removable.push(...existingRel.map((rel) => path54.resolve(root, rel)));
+    const id = row.id ?? "(unknown item)";
+    const existing = await resolveExistingTrackedPaths(root, id, row.paths ?? [], log);
+    if (existing.length === 0) continue;
+    const gate = await hashGateEntry(root, { hash: row.hash }, existing);
+    if (!gate.ok) {
+      preserved.push(...existing.map((e) => e.abs));
+      const detail = gate.reason === "no-hash" ? "has no lock hash" : "was modified locally";
+      log(`Preserving ${id} (${detail}): ${existing.map((e) => e.rel).join(", ")}`);
       continue;
     }
-    const currentHash = await hashInstalledPaths(root, existingRel);
-    if (currentHash === row.hash) {
-      removable.push(...existingRel.map((rel) => path54.resolve(root, rel)));
-    } else {
-      preserved.push(...existingRel.map((rel) => path54.resolve(root, rel)));
-      log(`Preserving locally-modified ${row.id ?? "(unknown item)"}: ${existingRel.join(", ")}`);
-    }
+    removable.push({ id, existing });
   }
   return { removable, preserved };
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs40.pathExists(settingsPath)) return false;
+  if (!await fs43.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path54.join(root, "CLAUDE.md");
-  if (!await fs40.pathExists(filePath)) return false;
-  const text = await fs40.readFile(filePath, "utf8");
+  const filePath = path55.join(root, "CLAUDE.md");
+  if (!await fs43.pathExists(filePath)) return false;
+  const text = await fs43.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs40.pathExists(settingsPath)) return false;
+  if (!await fs43.pathExists(settingsPath)) return false;
   let settings = await readProjectSettings(root);
   settings = stripHausHooks(stripHausAsk(stripHausAllow(stripHausDeny(settings))));
   const hasContent = Object.keys(settings).length > 0;
   if (hasContent) {
     await writeProjectSettings(root, settings);
-    log(`Stripped haus rules from ${path54.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path55.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs40.remove(settingsPath);
-  log(`Removed ${path54.relative(root, settingsPath)} (no user-owned settings remained).`);
+  await fs43.remove(settingsPath);
+  log(`Removed ${path55.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path54.join(root, "CLAUDE.md");
-  if (!await fs40.pathExists(filePath)) return false;
-  const prev = await fs40.readFile(filePath, "utf8");
+  const filePath = path55.join(root, "CLAUDE.md");
+  if (!await fs43.pathExists(filePath)) return false;
+  const prev = await fs43.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs40.remove(filePath);
+    await fs43.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs40.writeFile(filePath, next, "utf8");
+    await fs43.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs40.pathExists(dir)) return;
+  if (!await fs43.pathExists(dir)) return;
   try {
-    const entries = await fs40.readdir(dir);
-    if (entries.length === 0) await fs40.remove(dir);
+    const entries = await fs43.readdir(dir);
+    if (entries.length === 0) await fs43.remove(dir);
   } catch {
   }
 }
 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}`);
+  const backupRoot = hausPath(root, "backups", dirBackupDirName("undo", stamp));
   for (const abs of managedAbsPaths) {
-    if (!await fs40.pathExists(abs)) continue;
-    const rel = path54.relative(root, abs);
-    const backupPath = path54.join(backupRoot, rel);
-    await fs40.ensureDir(path54.dirname(backupPath));
-    await fs40.copy(abs, backupPath);
+    if (!await fs43.pathExists(abs)) continue;
+    const rel = path55.relative(root, abs);
+    const backupPath = path55.join(backupRoot, rel);
+    await fs43.ensureDir(path55.dirname(backupPath));
+    await fs43.copy(abs, backupPath);
   }
-  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path54.relative(root, backupRoot)}.`);
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path55.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
   const root = options.root ?? process.cwd();
   const coreManaged = await collectCoreManagedPaths(root);
   const { removable: lockRemovable, preserved: lockPreserved } = await collectLockTrackedPaths(root);
-  const managed = [.../* @__PURE__ */ new Set([...coreManaged, ...lockRemovable])];
+  const lockAbs = lockRemovable.flatMap(({ existing }) => existing.map((e) => e.abs));
+  const managed = [.../* @__PURE__ */ new Set([...coreManaged, ...lockAbs])];
   const stripSettings = await settingsHasHausContent(root);
   const stripClaudeMd = await claudeMdHasHausBlock(root);
   if (managed.length === 0 && !stripSettings && !stripClaudeMd) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path54.relative(root, p));
+  const relTargets = managed.map((p) => path55.relative(root, p));
   const summaryParts = [...relTargets];
   if (stripSettings) summaryParts.push(".claude/settings.json (haus rules only)");
   if (stripClaudeMd) summaryParts.push("CLAUDE.md (haus import block only)");
   if (lockPreserved.length > 0) {
-    summaryParts.push(
-      `(preserving ${lockPreserved.length} locally-modified catalog item file(s) \u2014 not shown above)`
-    );
+    summaryParts.push(`(preserving ${lockPreserved.length} catalog item file(s) \u2014 not shown above)`);
   }
   if (options.dryRun) {
     log(`[dry-run] Would remove:
@@ -11137,10 +11709,13 @@ User-owned .claude/ files will be preserved.`
     }
   }
   await backupManagedFilesBeforeUndo(root, managed);
-  for (const abs of managed) {
-    if (!await fs40.pathExists(abs)) continue;
-    await fs40.remove(abs);
-    log(`Removed ${path54.relative(root, abs)}`);
+  for (const abs of coreManaged) {
+    if (!await fs43.pathExists(abs)) continue;
+    await fs43.remove(abs);
+    log(`Removed ${path55.relative(root, abs)}`);
+  }
+  for (const { id, existing } of lockRemovable) {
+    await deleteTrackedPaths(root, id, existing, { verb: "Removed" }, log);
   }
   if (stripSettings) await stripProjectSettings(root);
   if (stripClaudeMd) await stripRootClaudeMd(root);
@@ -11154,8 +11729,8 @@ init_fs();
 init_logger();
 init_paths();
 import crypto3 from "node:crypto";
-import path55 from "node:path";
-import fs41 from "fs-extra";
+import path56 from "node:path";
+import fs44 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false, removePlugins = removeGlobalPlugins } = options;
   const manifest = await readManifest();
@@ -11192,7 +11767,7 @@ async function runUninstall(options = {}) {
     );
   }
   for (const entry of manifest.files) {
-    const exists = fs41.pathExistsSync(entry.destPath);
+    const exists = fs44.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -11210,23 +11785,23 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs41.remove(entry.destPath);
-    await pruneEmptyDir(path55.dirname(entry.destPath));
+    await fs44.remove(entry.destPath);
+    await pruneEmptyDir(path56.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
   const settings = await readSettings();
   const stripped = stripHausHooks(stripHausAsk(stripHausAllow(stripHausDeny(settings))));
   await writeSettings(stripped);
   result.hooksStripped = true;
-  const hausDir = path55.join(globalClaudeDir(), "haus");
+  const hausDir = path56.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs41.pathExistsSync(manifestPath2)) {
-    await fs41.remove(manifestPath2);
+  if (fs44.pathExistsSync(manifestPath2)) {
+    await fs44.remove(manifestPath2);
   }
-  if (fs41.pathExistsSync(hausDir)) {
+  if (fs44.pathExistsSync(hausDir)) {
     try {
-      const remaining = await fs41.readdir(hausDir);
-      if (remaining.length === 0) await fs41.remove(hausDir);
+      const remaining = await fs44.readdir(hausDir);
+      if (remaining.length === 0) await fs44.remove(hausDir);
     } catch {
     }
   }
@@ -11295,15 +11870,15 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/validate-catalog.ts
-import path57 from "node:path";
+import path58 from "node:path";
 
 // src/catalog/validate-core.ts
 init_forbidden_content();
 init_manifest_item_fields();
 init_path_safety();
 init_validation_rules2();
-import fs42 from "node:fs";
-import path56 from "node:path";
+import fs45 from "node:fs";
+import path57 from "node:path";
 var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
 var ITEM_ID_PATTERN = /^haus\./;
 function auditForbiddenStacks(items) {
@@ -11380,11 +11955,11 @@ function auditOptInMetadata(items) {
   }
   return failures;
 }
-function auditManifestStructure(manifestVersion, items) {
+function auditManifestStructure(manifestVersion2, items) {
   const failures = [];
   const seenIds = /* @__PURE__ */ new Map();
   const seenPaths = /* @__PURE__ */ new Map();
-  if (typeof manifestVersion !== "string" || !ITEM_SEMVER_RE.test(manifestVersion)) {
+  if (typeof manifestVersion2 !== "string" || !ITEM_SEMVER_RE.test(manifestVersion2)) {
     failures.push('manifest.json: top-level "version" is not valid semver (expected X.Y.Z)');
   }
   for (let i = 0; i < items.length; i++) {
@@ -11447,14 +12022,14 @@ function checkRequiredFrontmatter(text, label) {
 }
 function readForAudit(absPath, label, failures) {
   try {
-    return fs42.readFileSync(absPath, "utf8");
+    return fs45.readFileSync(absPath, "utf8");
   } catch (err) {
     failures.push(`${label}: unreadable (${err instanceof Error ? err.message : String(err)})`);
     return null;
   }
 }
 function auditTemplateContent(manifestDir, absPath, itemId) {
-  const rel = path56.relative(manifestDir, absPath);
+  const rel = path57.relative(manifestDir, absPath);
   const failures = [];
   const text = readForAudit(absPath, `${itemId}: ${rel}`, failures);
   if (text === null) return failures;
@@ -11476,55 +12051,55 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path || !isSafeCatalogPath(item.path)) continue;
-    const absPath = path56.join(manifestDir, item.path);
+    const absPath = path57.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path56.join(absPath, "SKILL.md");
-      if (!fs42.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path56.relative(manifestDir, skillMd)}`);
+      const skillMd = path57.join(absPath, "SKILL.md");
+      if (!fs45.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path57.relative(manifestDir, skillMd)}`);
         continue;
       }
       const text = readForAudit(skillMd, `${item.id}: SKILL.md`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: SKILL.md`));
       failures.push(
-        ...auditForbiddenTagsInText(text, `${item.id}: ${path56.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path57.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs42.existsSync(absPath)) {
+      if (!fs45.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const rel = path56.relative(manifestDir, absPath);
+      const rel = path57.relative(manifestDir, absPath);
       const text = readForAudit(absPath, `${item.id}: ${rel}`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditForbiddenTagsInText(text, `${item.id}: ${rel}`));
     } else if (item.type === "template") {
-      if (!fs42.existsSync(absPath)) {
+      if (!fs45.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 (!fs42.existsSync(absPath)) {
+      if (!fs45.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
-      const rel = path56.relative(manifestDir, absPath);
+      const rel = path57.relative(manifestDir, absPath);
       const text = readForAudit(absPath, `${item.id}: ${rel}`, failures);
       if (text === null) continue;
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditTemplateContent(manifestDir, absPath, item.id));
     } else if (item.type === "config") {
-      if (!fs42.existsSync(absPath)) {
+      if (!fs45.existsSync(absPath)) {
         failures.push(`${item.id}: missing config path ${item.path}`);
       }
     } else if (item.type === "rule") {
-      if (!fs42.existsSync(absPath)) {
+      if (!fs45.existsSync(absPath)) {
         failures.push(`${item.id}: missing rule file ${item.path}`);
       }
     } else if (item.type === "asset") {
-      if (!fs42.existsSync(absPath)) {
+      if (!fs45.existsSync(absPath)) {
         failures.push(`${item.id}: missing asset file ${item.path}`);
       }
     }
@@ -11559,7 +12134,7 @@ function resolveItemType(relPath, pathTypeMap) {
 function walkAllFiles(dir, fn, failures) {
   let entries;
   try {
-    entries = fs42.readdirSync(dir, { withFileTypes: true });
+    entries = fs45.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -11568,7 +12143,7 @@ function walkAllFiles(dir, fn, failures) {
   }
   for (const entry of entries) {
     if (entry.name === ".DS_Store") continue;
-    const full = path56.join(dir, entry.name);
+    const full = path57.join(dir, entry.name);
     if (entry.isDirectory()) walkAllFiles(full, fn, failures);
     else fn(full);
   }
@@ -11592,12 +12167,12 @@ function auditDiskOrphans(manifestDir, items) {
   const failures = [];
   const claimedPaths = items.filter((item) => item.path && isSafeCatalogPath(item.path)).map((item) => item.path.replace(/\\/g, "/"));
   for (const dir of CONTENT_ROOTS) {
-    const abs = path56.join(manifestDir, dir);
-    if (!fs42.existsSync(abs)) continue;
+    const abs = path57.join(manifestDir, dir);
+    if (!fs45.existsSync(abs)) continue;
     walkAllFiles(
       abs,
       (file) => {
-        const relPath = path56.relative(manifestDir, file).replace(/\\/g, "/");
+        const relPath = path57.relative(manifestDir, file).replace(/\\/g, "/");
         if (!isPathClaimed(relPath, claimedPaths)) {
           failures.push(`orphaned on disk, claimed by no manifest item: ${relPath}`);
         }
@@ -11610,7 +12185,7 @@ function auditDiskOrphans(manifestDir, items) {
 function walkMd(dir, fn, failures) {
   let entries;
   try {
-    entries = fs42.readdirSync(dir, { withFileTypes: true });
+    entries = fs45.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -11618,7 +12193,7 @@ function walkMd(dir, fn, failures) {
     return;
   }
   for (const entry of entries) {
-    const full = path56.join(dir, entry.name);
+    const full = path57.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn, failures);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -11628,13 +12203,13 @@ function auditMarkdownContent(manifestDir, items) {
   const pathSourceMap = buildItemPathSourceMap(items);
   const pathTypeMap = buildItemPathTypeMap(items);
   for (const dir of ["skills", "agents", "templates", "commands", "sources"]) {
-    const abs = path56.join(manifestDir, dir);
-    if (!fs42.existsSync(abs)) continue;
+    const abs = path57.join(manifestDir, dir);
+    if (!fs45.existsSync(abs)) continue;
     const dirType = DIR_ITEM_TYPE[dir] ?? "";
     walkMd(
       abs,
       (file) => {
-        const rel = path56.relative(manifestDir, file);
+        const rel = path57.relative(manifestDir, file);
         const text = readForAudit(file, rel, failures);
         if (text === null) return;
         const norm = rel.replace(/\\/g, "/");
@@ -11657,9 +12232,9 @@ function auditMarkdownContent(manifestDir, items) {
   }
   return failures;
 }
-function validateCatalogData(manifestDir, manifestVersion, items) {
+function validateCatalogData(manifestDir, manifestVersion2, items) {
   const failures = [
-    ...auditManifestStructure(manifestVersion, items),
+    ...auditManifestStructure(manifestVersion2, items),
     ...validateFormerIds(items),
     ...auditOptInMetadata(items),
     ...auditForbiddenStacks(items),
@@ -11682,8 +12257,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path57.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path57.dirname(abs);
+  const abs = path58.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path58.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -11704,8 +12279,8 @@ init_logger();
 
 // src/workspace/worktree/add.ts
 init_fs();
-import path64 from "node:path";
-import fs46 from "fs-extra";
+import path65 from "node:path";
+import fs49 from "fs-extra";
 
 // src/workspace/worktree/git-worktree.ts
 init_exec();
@@ -11825,13 +12400,13 @@ async function hasUnpushedWork(cwd) {
 }
 
 // src/workspace/worktree/hydrate.ts
-import path60 from "node:path";
-import fs44 from "fs-extra";
+import path61 from "node:path";
+import fs47 from "fs-extra";
 
 // src/workspace/worktree/cow-copy.ts
 init_exec();
-import path58 from "node:path";
-import fs43 from "fs-extra";
+import path59 from "node:path";
+import fs46 from "fs-extra";
 async function getMacFilesystemType(dir) {
   const df = await runCommand("df", ["-P", dir]);
   if (df.exitCode !== 0) return void 0;
@@ -11862,14 +12437,14 @@ async function detectCowStrategy(dir) {
   return "unknown-platform";
 }
 async function cowCopyDir(src, dest) {
-  const srcExists = await fs43.pathExists(src);
+  const srcExists = await fs46.pathExists(src);
   if (!srcExists)
     return { strategy: "unsupported", attempted: false, ok: false, error: "source missing" };
-  const strategy = await detectCowStrategy(path58.dirname(dest));
+  const strategy = await detectCowStrategy(path59.dirname(dest));
   if (strategy === "unsupported" || strategy === "unknown-platform") {
     return { strategy, attempted: false, ok: false };
   }
-  await fs43.ensureDir(path58.dirname(dest));
+  await fs46.ensureDir(path59.dirname(dest));
   const args = strategy === "darwin-clonefile" ? ["-c", "-R", src, dest] : ["-a", "--reflink=always", src, dest];
   const result = await runCommand("cp", args);
   return {
@@ -11883,7 +12458,7 @@ async function cowCopyDir(src, dest) {
 // src/workspace/worktree/install.ts
 init_exec();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 import fg6 from "fast-glob";
 function detectInstallPlan(signals) {
   if (signals.hasYarnLock) {
@@ -11904,10 +12479,10 @@ function detectInstallPlan(signals) {
   return { manager: "none" };
 }
 async function computeLockfileSignals(dir) {
-  const hasYarnLock = existsSync3(path59.join(dir, "yarn.lock"));
-  const hasPnpmLock = existsSync3(path59.join(dir, "pnpm-lock.yaml"));
-  const hasPackageLock = existsSync3(path59.join(dir, "package-lock.json"));
-  const hasComposerLock = existsSync3(path59.join(dir, "composer.lock"));
+  const hasYarnLock = existsSync3(path60.join(dir, "yarn.lock"));
+  const hasPnpmLock = existsSync3(path60.join(dir, "pnpm-lock.yaml"));
+  const hasPackageLock = existsSync3(path60.join(dir, "package-lock.json"));
+  const hasComposerLock = existsSync3(path60.join(dir, "composer.lock"));
   const dotnetFiles = await fg6(["**/*.csproj", "**/*.sln"], {
     cwd: dir,
     onlyFiles: true,
@@ -11921,7 +12496,7 @@ async function computeLockfileSignals(dir) {
   });
   const hasDotnetProject = dotnetFiles.length > 0;
   let hasPackageManagerField = false;
-  const pkgPath = path59.join(dir, "package.json");
+  const pkgPath = path60.join(dir, "package.json");
   if (existsSync3(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
@@ -11964,7 +12539,7 @@ function missingYarnrcEnvVars(content2, env) {
   return findRequiredYarnrcEnvVars(content2).filter((name) => env[name] === void 0);
 }
 function missingYarnrcEnvVarsInDir(dir, env) {
-  const yarnrcPath = path59.join(dir, ".yarnrc.yml");
+  const yarnrcPath = path60.join(dir, ".yarnrc.yml");
   if (!existsSync3(yarnrcPath)) return [];
   try {
     return missingYarnrcEnvVars(readFileSync3(yarnrcPath, "utf8"), env);
@@ -12054,13 +12629,13 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
   const start = Date.now();
   const targets = [];
   for (const target of HYDRATION_TARGETS) {
-    const src = path60.join(mainMemberPath, target);
-    const dest = path60.join(worktreeMemberPath, target);
-    if (!await fs44.pathExists(src)) continue;
-    const destExists = await fs44.pathExists(dest);
+    const src = path61.join(mainMemberPath, target);
+    const dest = path61.join(worktreeMemberPath, target);
+    if (!await fs47.pathExists(src)) continue;
+    const destExists = await fs47.pathExists(dest);
     if (!opts.force && destExists) continue;
     if (opts.force && destExists) {
-      await fs44.remove(dest);
+      await fs47.remove(dest);
     }
     const copy = await cowCopyDir(src, dest);
     targets.push({ target, copy });
@@ -12073,11 +12648,11 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
 
 // src/workspace/worktree/local-files.ts
 init_exec();
-import path61 from "node:path";
-import fs45 from "fs-extra";
+import path62 from "node:path";
+import fs48 from "fs-extra";
 var MACHINE_LOCAL_FILES = [
   "docker-compose.local.yml",
-  path61.join(".claude", "settings.local.json")
+  path62.join(".claude", "settings.local.json")
 ];
 async function isTracked(repoRoot, relFile) {
   const gitPath = relFile.replace(/\\/g, "/");
@@ -12087,12 +12662,12 @@ async function isTracked(repoRoot, relFile) {
 async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
   const copied = [];
   for (const rel of MACHINE_LOCAL_FILES) {
-    const src = path61.join(mainMemberPath, rel);
-    if (!await fs45.pathExists(src)) continue;
+    const src = path62.join(mainMemberPath, rel);
+    if (!await fs48.pathExists(src)) continue;
     if (await isTracked(mainMemberPath, rel)) continue;
-    const dest = path61.join(worktreeMemberPath, rel);
-    await fs45.ensureDir(path61.dirname(dest));
-    await fs45.copy(src, dest, { overwrite: true });
+    const dest = path62.join(worktreeMemberPath, rel);
+    await fs48.ensureDir(path62.dirname(dest));
+    await fs48.copy(src, dest, { overwrite: true });
     copied.push(rel);
   }
   return copied;
@@ -12100,15 +12675,15 @@ async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
 
 // src/workspace/worktree/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 async function resolveWorkspaceForWorktree(start) {
   const rootInfo = await resolveRoots(start);
   if (!rootInfo.isGitRepo) {
     return { ok: false, reason: "Not inside a git repository." };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const hasYaml = existsSync4(path62.join(workspaceRoot, WORKSPACE_FILE));
-  const hasManifest = existsSync4(path62.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const hasYaml = existsSync4(path63.join(workspaceRoot, WORKSPACE_FILE));
+  const hasManifest = existsSync4(path63.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!hasYaml && !hasManifest) {
     return {
       ok: false,
@@ -12134,10 +12709,10 @@ function selectMembers(members, only) {
 
 // src/workspace/worktree/state.ts
 init_fs();
-import path63 from "node:path";
+import path64 from "node:path";
 var WORKTREE_STATE_FILE = ".haus-worktree.json";
 function worktreesDir(mainRoot) {
-  return path63.join(mainRoot, ".claude", "worktrees");
+  return path64.join(mainRoot, ".claude", "worktrees");
 }
 function isValidWorktreeSlug(slug) {
   if (slug === "" || slug === "." || slug === "..") return false;
@@ -12150,15 +12725,15 @@ function worktreePath(mainRoot, slug) {
       `Invalid worktree slug ${JSON.stringify(slug)} \u2014 slugs may only contain letters, digits, ".", "_", "-" (no path separators, and not "." or "..").`
     );
   }
-  return path63.join(worktreesDir(mainRoot), slug);
+  return path64.join(worktreesDir(mainRoot), slug);
 }
 async function readWorktreeState(worktreeRoot) {
-  const state = await readJson(path63.join(worktreeRoot, WORKTREE_STATE_FILE));
+  const state = await readJson(path64.join(worktreeRoot, WORKTREE_STATE_FILE));
   if (state == null || typeof state !== "object" || !Array.isArray(state.members)) return void 0;
   return state;
 }
 async function writeWorktreeState(worktreeRoot, state) {
-  await writeJson(path63.join(worktreeRoot, WORKTREE_STATE_FILE), state);
+  await writeJson(path64.join(worktreeRoot, WORKTREE_STATE_FILE), state);
 }
 
 // src/workspace/worktree/add.ts
@@ -12173,7 +12748,7 @@ async function runAdd(opts) {
   }
   const branch = opts.branch ?? opts.slug;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (await fs46.pathExists(wsWorktreePath)) {
+  if (await fs49.pathExists(wsWorktreePath)) {
     return {
       ok: false,
       error: `Workspace worktree already exists at ${wsWorktreePath} \u2014 run \`haus workspace worktree hydrate --materialize\` from inside it to check out any missing members (e.g. a worktree created by plain \`git worktree add\`), or \`remove\` first to start over.`
@@ -12192,7 +12767,7 @@ async function runAdd(opts) {
   const memberResults = [];
   for (const member of selected) {
     const start = Date.now();
-    const memberWorktreePath = path64.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path65.join(wsWorktreePath, member.folder);
     const outcome = await addWorktree(member.absPath, memberWorktreePath, branch, {
       preferDefaultBranchFrom: true
     });
@@ -12222,7 +12797,7 @@ async function runAdd(opts) {
   await mapWithConcurrency(okResults, async (result) => {
     const member = selected.find((m) => m.id === result.member);
     if (!member) return;
-    const memberWorktreePath = path64.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path65.join(wsWorktreePath, member.folder);
     const hydrationStart = Date.now();
     if (opts.hydrate !== false) {
       result.hydration = await hydrateMember(member.absPath, memberWorktreePath);
@@ -12289,25 +12864,25 @@ async function runDryRun(args) {
 
 // src/workspace/worktree/doctor.ts
 import { existsSync as existsSync6 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 
 // src/workspace/worktree/orphans.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path65 from "node:path";
+import path66 from "node:path";
 var WORKSPACE_REPO_ID = "(workspace)";
 async function findOrphanedRegistrations(repos, wsWorktreesDir) {
   const orphans = [];
   for (const repo of repos) {
     const entries = await listWorktrees(repo.absPath);
     for (const entry of entries) {
-      const entryPath = path65.normalize(entry.path);
-      const marker = `${path65.sep}.claude${path65.sep}worktrees${path65.sep}`;
+      const entryPath = path66.normalize(entry.path);
+      const marker = `${path66.sep}.claude${path66.sep}worktrees${path66.sep}`;
       const idx = entryPath.indexOf(marker);
       if (idx === -1) continue;
       const rest = entryPath.slice(idx + marker.length);
-      const slug = rest.split(path65.sep)[0];
+      const slug = rest.split(path66.sep)[0];
       if (!slug) continue;
-      if (existsSync5(path65.join(wsWorktreesDir, slug))) continue;
+      if (existsSync5(path66.join(wsWorktreesDir, slug))) continue;
       orphans.push({
         repoId: repo.id,
         ownerRepo: repo.absPath,
@@ -12322,7 +12897,7 @@ async function findOrphanedRegistrations(repos, wsWorktreesDir) {
 // src/workspace/worktree/doctor.ts
 var HYDRATION_MARKERS = ["node_modules", "vendor", "obj", "bin"];
 function looksHydrated(memberPath) {
-  return HYDRATION_MARKERS.some((marker) => existsSync6(path66.join(memberPath, marker)));
+  return HYDRATION_MARKERS.some((marker) => existsSync6(path67.join(memberPath, marker)));
 }
 async function runDoctor2() {
   const rootInfo = await resolveRoots();
@@ -12338,7 +12913,7 @@ async function runDoctor2() {
     };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const isWorkspace = existsSync6(path66.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path66.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const isWorkspace = existsSync6(path67.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path67.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!isWorkspace) {
     return {
       isWorkspace: false,
@@ -12353,7 +12928,7 @@ async function runDoctor2() {
     };
   }
   const wsWorktreesDir = worktreesDir(workspaceRoot);
-  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path66.sep}`);
+  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path67.sep}`);
   const inWorkspaceWorktree = rootInfo.isLinkedWorktree && underWorktreesDir;
   const workspaceConfig = await readWorkspaceConfig(workspaceRoot);
   const autoHydrate = workspaceConfig?.worktree?.autoHydrate === true;
@@ -12364,10 +12939,10 @@ async function runDoctor2() {
   let slug;
   if (inWorkspaceWorktree) {
     const wtPath = rootInfo.repoRoot;
-    slug = rootInfo.worktreeName ?? path66.basename(wtPath);
+    slug = rootInfo.worktreeName ?? path67.basename(wtPath);
     const state = await readWorktreeState(wtPath);
     for (const member of members) {
-      const memberPath = path66.join(wtPath, member.folder);
+      const memberPath = path67.join(wtPath, member.folder);
       const materialized = existsSync6(memberPath);
       const expectedBranch = state?.members.find((m) => m.folder === member.folder)?.branch ?? state?.branch;
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
@@ -12407,7 +12982,7 @@ async function runDoctor2() {
     wsWorktreesDir
   );
   const orphans = orphanScan.map(
-    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path66.join(wsWorktreesDir, o.slug)} no longer exists.`
+    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path67.join(wsWorktreesDir, o.slug)} no longer exists.`
   );
   if (orphans.length > 0) {
     problems.push(...orphans);
@@ -12428,7 +13003,7 @@ async function runDoctor2() {
 // src/workspace/worktree/hydrate-command.ts
 init_fs();
 import { existsSync as existsSync7 } from "node:fs";
-import path67 from "node:path";
+import path68 from "node:path";
 async function runHydrateWorktree(opts) {
   const rootInfo = await resolveRoots();
   if (!rootInfo.isGitRepo || !rootInfo.isLinkedWorktree) {
@@ -12439,7 +13014,7 @@ async function runHydrateWorktree(opts) {
   }
   const workspaceRoot = rootInfo.mainRoot;
   const wtPath = rootInfo.repoRoot;
-  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path67.sep}`)) {
+  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path68.sep}`)) {
     return {
       ok: false,
       error: "Current worktree is not one of this workspace's .claude/worktrees/<slug> checkouts."
@@ -12451,13 +13026,13 @@ async function runHydrateWorktree(opts) {
     return { ok: false, error: `Unknown --only repo(s): ${unknown.join(", ")}` };
   }
   const state = await readWorktreeState(wtPath);
-  const slug = state?.slug ?? path67.basename(wtPath);
+  const slug = state?.slug ?? path68.basename(wtPath);
   const detectedBranch = await currentBranch(wtPath);
   const targetBranch = state?.branch ?? (detectedBranch !== "HEAD" ? detectedBranch : void 0) ?? slug;
   if (opts.dryRun) {
     const results2 = await Promise.all(
       selected.map(async (member) => {
-        const memberPath = path67.join(wtPath, member.folder);
+        const memberPath = path68.join(wtPath, member.folder);
         if (existsSync7(memberPath)) {
           return { member: member.id, folder: member.folder, status: "planned" };
         }
@@ -12478,7 +13053,7 @@ async function runHydrateWorktree(opts) {
   const results = await mapWithConcurrency(
     selected,
     async (member) => {
-      const memberPath = path67.join(wtPath, member.folder);
+      const memberPath = path68.join(wtPath, member.folder);
       let branchAction;
       if (!existsSync7(memberPath)) {
         if (!opts.materialize) {
@@ -12541,26 +13116,26 @@ async function runHydrateWorktree(opts) {
 }
 
 // src/workspace/worktree/list.ts
-import path68 from "node:path";
-import fs47 from "fs-extra";
+import path69 from "node:path";
+import fs50 from "fs-extra";
 async function runList2() {
   const resolved = await resolveWorkspaceForWorktree();
   if (!resolved.ok) return { ok: false, error: resolved.reason };
   const { rootInfo, workspaceRoot } = resolved;
   const dir = worktreesDir(workspaceRoot);
-  if (!await fs47.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
-  const entries = await fs47.readdir(dir, { withFileTypes: true });
+  if (!await fs50.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
+  const entries = await fs50.readdir(dir, { withFileTypes: true });
   const slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   const configuredMembers = await readMembers(rootInfo);
   const worktrees = [];
   for (const slug of slugs) {
-    const wtPath = path68.join(dir, slug);
+    const wtPath = path69.join(dir, slug);
     const state = await readWorktreeState(wtPath);
     const members = [];
     const source = state?.members ?? configuredMembers.map((m) => ({ id: m.id, folder: m.folder }));
     for (const m of source) {
-      const memberPath = path68.join(wtPath, m.folder);
-      const materialized = await fs47.pathExists(memberPath);
+      const memberPath = path69.join(wtPath, m.folder);
+      const materialized = await fs50.pathExists(memberPath);
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
       members.push({
         id: m.id,
@@ -12621,14 +13196,14 @@ async function runPrune2(opts) {
 }
 
 // src/workspace/worktree/remove.ts
-import path69 from "node:path";
-import fs48 from "fs-extra";
+import path70 from "node:path";
+import fs51 from "fs-extra";
 async function runRemove2(opts) {
   const resolved = await resolveWorkspaceForWorktree();
   if (!resolved.ok) return { ok: false, error: resolved.reason };
   const { rootInfo, workspaceRoot } = resolved;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (!await fs48.pathExists(wsWorktreePath)) {
+  if (!await fs51.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const state = await readWorktreeState(wsWorktreePath);
@@ -12648,12 +13223,12 @@ async function runRemove2(opts) {
     targets.push({
       repo: configMember?.id ?? stateMember.id,
       ownerRepo,
-      path: path69.join(wsWorktreePath, stateMember.folder)
+      path: path70.join(wsWorktreePath, stateMember.folder)
     });
   }
   const existingTargets = [];
   for (const target of targets) {
-    if (await fs48.pathExists(target.path)) existingTargets.push(target);
+    if (await fs51.pathExists(target.path)) existingTargets.push(target);
   }
   if (!opts.force) {
     const blockers = [];
@@ -12709,8 +13284,8 @@ async function runRemove2(opts) {
     }
     await pruneWorktrees(workspaceRoot);
   }
-  if (wsRemoveOk && await fs48.pathExists(wsWorktreePath)) {
-    await fs48.remove(wsWorktreePath);
+  if (wsRemoveOk && await fs51.pathExists(wsWorktreePath)) {
+    await fs51.remove(wsWorktreePath);
   }
   return { ok: failed.length === 0, dryRun: false, slug: opts.slug, removed, failed };
 }
@@ -12986,7 +13561,7 @@ async function runWorktree(action, opts = {}) {
 
 // src/commands/workspace.ts
 import { existsSync as existsSync11, statSync as statSync3 } from "node:fs";
-import path78 from "node:path";
+import path79 from "node:path";
 init_fs();
 init_logger();
 
@@ -13045,7 +13620,7 @@ ${summaries.map(
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync8 } from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 init_logger();
 init_paths();
 
@@ -13053,14 +13628,14 @@ init_paths();
 init_fs();
 init_paths();
 import { readFileSync as readFileSync4 } from "node:fs";
-import path70 from "node:path";
-var MANIFEST_FILE = "workspace.manifest.json";
+import path71 from "node:path";
+var MANIFEST_FILE2 = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
-  return hausPath(workspaceRoot, MANIFEST_FILE);
+  return hausPath(workspaceRoot, MANIFEST_FILE2);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync4(path70.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path71.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -13152,7 +13727,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
   const manifestByName = new Map(manifest.repos.map((r) => [r.name, r]));
   const catalogRefByRepo = [];
   for (const repo of config.repos) {
-    const repoRoot = path71.resolve(workspaceRoot, repo.path);
+    const repoRoot = path72.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -13225,7 +13800,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         });
         continue;
       }
-      if (!existsSync8(path71.join(workspaceRoot, entry.path))) {
+      if (!existsSync8(path72.join(workspaceRoot, entry.path))) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-copy",
@@ -13271,18 +13846,18 @@ function emit(args) {
 init_logger();
 
 // src/workspace/link-context/link.ts
-import path74 from "node:path";
-import fs51 from "fs-extra";
+import path75 from "node:path";
+import fs54 from "fs-extra";
 init_fs();
 init_logger();
 
 // src/workspace/link-context/plan.ts
-import path73 from "node:path";
-import fs50 from "fs-extra";
+import path74 from "node:path";
+import fs53 from "fs-extra";
 
 // src/workspace/link-context/scan-source.ts
-import path72 from "node:path";
-import fs49 from "fs-extra";
+import path73 from "node:path";
+import fs52 from "fs-extra";
 var ASSET_SUBDIR = {
   skill: "skills",
   agent: "agents",
@@ -13290,36 +13865,36 @@ var ASSET_SUBDIR = {
 };
 async function hasLinkableContext(member) {
   for (const subdir of Object.values(ASSET_SUBDIR)) {
-    if (await fs49.pathExists(path72.join(member.absPath, ".claude", subdir))) return true;
+    if (await fs52.pathExists(path73.join(member.absPath, ".claude", subdir))) return true;
   }
   return false;
 }
 async function collectSkills(member) {
-  const dir = path72.join(member.absPath, ".claude", "skills");
-  if (!await fs49.pathExists(dir)) return [];
-  const names = await fs49.readdir(dir);
+  const dir = path73.join(member.absPath, ".claude", "skills");
+  if (!await fs52.pathExists(dir)) return [];
+  const names = await fs52.readdir(dir);
   const out = [];
   for (const name of [...names].sort()) {
-    const abs = path72.join(dir, name);
-    const stat = await fs49.lstat(abs);
+    const abs = path73.join(dir, name);
+    const stat = await fs52.lstat(abs);
     if (!stat.isDirectory()) continue;
-    if (!await fs49.pathExists(path72.join(abs, "SKILL.md"))) continue;
-    out.push({ type: "skill", name, sourceRelPath: path72.posix.join(".claude", "skills", name) });
+    if (!await fs52.pathExists(path73.join(abs, "SKILL.md"))) continue;
+    out.push({ type: "skill", name, sourceRelPath: path73.posix.join(".claude", "skills", name) });
   }
   return out;
 }
 async function collectFlatMarkdown(member, type) {
   const subdir = ASSET_SUBDIR[type];
-  const dir = path72.join(member.absPath, ".claude", subdir);
-  if (!await fs49.pathExists(dir)) return [];
-  const names = await fs49.readdir(dir);
+  const dir = path73.join(member.absPath, ".claude", subdir);
+  if (!await fs52.pathExists(dir)) return [];
+  const names = await fs52.readdir(dir);
   const out = [];
   for (const fileName of [...names].sort()) {
     if (!fileName.endsWith(".md")) continue;
-    const abs = path72.join(dir, fileName);
-    if (!(await fs49.lstat(abs)).isFile()) continue;
+    const abs = path73.join(dir, fileName);
+    if (!(await fs52.lstat(abs)).isFile()) continue;
     const name = fileName.slice(0, -".md".length);
-    out.push({ type, name, sourceRelPath: path72.posix.join(".claude", subdir, fileName) });
+    out.push({ type, name, sourceRelPath: path73.posix.join(".claude", subdir, fileName) });
   }
   return out;
 }
@@ -13334,9 +13909,9 @@ async function collectSourceAssets(member) {
 
 // src/workspace/link-context/plan.ts
 function repoFolderPrefix(member) {
-  const base = path73.posix.basename(member.folder);
+  const base = path74.posix.basename(member.folder);
   if (base && base !== "." && base !== "/") return base;
-  const fromAbs = path73.basename(member.absPath);
+  const fromAbs = path74.basename(member.absPath);
   return fromAbs || member.id;
 }
 function assetKey(type, destKey) {
@@ -13351,7 +13926,7 @@ async function buildLinkPlan(members) {
   const byKey = /* @__PURE__ */ new Map();
   const membersById = new Map(members.map((m) => [m.id, m]));
   for (const member of members) {
-    if (!await fs50.pathExists(member.absPath)) {
+    if (!await fs53.pathExists(member.absPath)) {
       skipped.push({ repo: member.id, reason: `not cloned locally (${member.absPath}) \u2014 skipped` });
       continue;
     }
@@ -13393,7 +13968,7 @@ async function buildLinkPlan(members) {
       name: asset.name,
       destKey,
       sourceRelPath: asset.sourceRelPath,
-      sourceAbsPath: path73.join(member.absPath, asset.sourceRelPath),
+      sourceAbsPath: path74.join(member.absPath, asset.sourceRelPath),
       sourceHash
     });
   }
@@ -13404,7 +13979,7 @@ async function buildLinkPlan(members) {
 function destRelPathFor(type, destKey) {
   const subdir = `${type}s`;
   const leaf = type === "skill" ? destKey : `${destKey}.md`;
-  return path74.posix.join(".claude", subdir, leaf);
+  return path75.posix.join(".claude", subdir, leaf);
 }
 async function runLinkContext(workspaceRoot, opts = {}) {
   const write = resolveWriteMode(opts, "preview-by-default").kind === "write";
@@ -13430,17 +14005,17 @@ async function runLinkContext(workspaceRoot, opts = {}) {
   const linkedAt = (/* @__PURE__ */ new Date()).toISOString();
   for (const entry of plan.entries) {
     const destRel = destRelPathFor(entry.type, entry.destKey);
-    const destAbs = path74.join(workspaceRoot, destRel);
+    const destAbs = path75.join(workspaceRoot, destRel);
     if (write) {
-      await fs51.ensureDir(path74.dirname(destAbs));
-      if (await fs51.pathExists(destAbs)) await fs51.remove(destAbs);
-      await fs51.copy(entry.sourceAbsPath, destAbs, {
+      await fs54.ensureDir(path75.dirname(destAbs));
+      if (await fs54.pathExists(destAbs)) await fs54.remove(destAbs);
+      await fs54.copy(entry.sourceAbsPath, destAbs, {
         overwrite: true,
         errorOnExist: false,
         dereference: false,
         filter: (s) => {
           try {
-            return !fs51.lstatSync(s).isSymbolicLink();
+            return !fs54.lstatSync(s).isSymbolicLink();
           } catch {
             return false;
           }
@@ -13469,7 +14044,7 @@ async function runLinkContext(workspaceRoot, opts = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${old.path}`);
         continue;
       }
-      if (await fs51.pathExists(abs)) await fs51.remove(abs);
+      if (await fs54.pathExists(abs)) await fs54.remove(abs);
     }
   }
   if (write) {
@@ -13521,11 +14096,11 @@ async function runWorkspaceLinkContext(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync9, statSync } from "node:fs";
-import path76 from "node:path";
+import path77 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path75 from "node:path";
-import fs52 from "fs-extra";
+import path76 from "node:path";
+import fs55 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -13547,11 +14122,11 @@ ${WORKSPACE_BLOCK_END}`;
 async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
   const block = buildWorkspaceImportBlock(opts.client, opts.members);
   const dryRun = opts.dryRun ?? false;
-  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path75.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path76.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
-  const existed = await fs52.pathExists(filePath);
-  const prev = existed ? await fs52.readFile(filePath, "utf8") : "";
+  const existed = await fs55.pathExists(filePath);
+  const prev = existed ? await fs55.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block, WORKSPACE_SENTINELS);
   const printable = displayPath(workspaceRoot, filePath);
@@ -13580,20 +14155,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 init_fs();
 init_logger();
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path76.resolve(start);
+  let dir = path77.resolve(start);
   for (; ; ) {
-    if (existsSync9(path76.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path76.dirname(dir);
-    if (parent === dir) return path76.resolve(start);
+    if (existsSync9(path77.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path77.dirname(dir);
+    if (parent === dir) return path77.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path76.resolve(workspaceRoot, repoPath) === path76.resolve(workspaceRoot);
+  return path77.resolve(workspaceRoot, repoPath) === path77.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path76.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path77.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -13620,37 +14195,52 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path76.resolve(workspaceRoot, repo.path);
+    const repoRoot = path77.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
+    let res;
     try {
       if (!existsSync9(repoRoot) || !statSync(repoRoot).isDirectory()) {
         throw new Error(`Repo path is not a directory: ${repo.path}`);
       }
-      const res = await runSetupCore(repoRoot, {
+      res = await runSetupCore(repoRoot, {
         apply,
         dryRun: options.dryRun,
         // Under --json, mute the inner pipeline entirely; we serialize the
         // aggregated result below. Otherwise let it print its normal human output.
-        quiet: options.json
+        quiet: options.json,
+        allowEmptyCache: options.allowEmptyCache
       });
+    } catch (err) {
+      const message2 = err instanceof Error ? err.message : String(err);
       statuses.push({
         name: repo.name,
         path: repo.path,
         root: repoRoot,
-        status: "ok",
-        roles: res.roles,
-        recommendedCount: res.recommendedCount
+        status: "failed",
+        error: message2
       });
-      const context = await readContextOrScan(repoRoot);
-      aggregateInputs.push({ name: repo.name, path: repo.path, context });
-    } catch (err) {
-      const message2 = err instanceof Error ? err.message : String(err);
+      if (!options.continueOnError) {
+        if (options.json) {
+          const result2 = { workspaceRoot, statuses, written: [] };
+          log(JSON.stringify(result2, null, 2));
+          process.exitCode = 1;
+          return result2;
+        }
+        throw new Error(`Setup failed for ${repo.name}: ${message2}`, { cause: err });
+      }
+      error(`Setup failed for ${repo.name}: ${message2}`);
+      continue;
+    }
+    if (!res.catalogInstallOk) {
+      const message2 = "No catalog items were installed for this repo (zero installable content) \u2014 see the per-repo output above, or re-run with --allow-empty-cache.";
       statuses.push({
         name: repo.name,
         path: repo.path,
         root: repoRoot,
         status: "failed",
+        roles: res.roles,
+        recommendedCount: res.recommendedCount,
         error: message2
       });
       if (!options.continueOnError) {
@@ -13660,10 +14250,21 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
           process.exitCode = 1;
           return result2;
         }
-        throw new Error(`Setup failed for ${repo.name}: ${message2}`, { cause: err });
+        throw new Error(`Setup failed for ${repo.name}: ${message2}`);
       }
       error(`Setup failed for ${repo.name}: ${message2}`);
+      continue;
     }
+    statuses.push({
+      name: repo.name,
+      path: repo.path,
+      root: repoRoot,
+      status: "ok",
+      roles: res.roles,
+      recommendedCount: res.recommendedCount
+    });
+    const context = await readContextOrScan(repoRoot);
+    aggregateInputs.push({ name: repo.name, path: repo.path, context });
   }
   const written = [];
   if (apply && aggregateInputs.length > 0) {
@@ -13710,7 +14311,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(path76.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path77.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -13766,7 +14367,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
     try {
       const linkResult = await runLinkContext(workspaceRoot, { write: true, json: options.json });
       if (linkResult.ok) {
-        written.push(...linkResult.added.map((rel) => path76.join(workspaceRoot, rel)));
+        written.push(...linkResult.added.map((rel) => path77.join(workspaceRoot, rel)));
         if (!options.json) {
           say(
             `Linked ${linkResult.linked.length} cross-repo skill/agent/command copy(ies) into .claude/ (${linkResult.added.length} new, ${linkResult.removed.length} removed)${linkResult.skipped.length > 0 ? ` \u2014 ${linkResult.skipped.length} member(s) skipped, see above` : ""}.`
@@ -13783,6 +14384,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   }
   const ok = statuses.filter((s) => s.status === "ok").length;
   const failed = statuses.length - ok;
+  if (failed > 0) process.exitCode = 1;
   const result = { workspaceRoot, statuses, written };
   if (options.json) {
     log(JSON.stringify(result, null, 2));
@@ -13798,8 +14400,8 @@ Workspace setup complete: ${ok} ok, ${failed} failed. Wrote ${written.length} fi
 
 // src/commands/workspace/undo.ts
 import { existsSync as existsSync10, statSync as statSync2 } from "node:fs";
-import path77 from "node:path";
-import fs53 from "fs-extra";
+import path78 from "node:path";
+import fs56 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -13829,7 +14431,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   if (options.dryRun) {
     for (const repo of config.repos) {
-      const repoRoot = path77.resolve(workspaceRoot, repo.path);
+      const repoRoot = path78.resolve(workspaceRoot, repo.path);
       log(`
 \u2192 ${repo.name} (${repo.path})`);
       try {
@@ -13850,7 +14452,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
         continue;
       }
-      if (await fs53.pathExists(abs)) {
+      if (await fs56.pathExists(abs)) {
         log(`[dry-run] Would remove ${entry.path} (linked ${entry.type} from ${entry.repo})`);
       }
     }
@@ -13860,12 +14462,12 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       hausPath(workspaceRoot, "WORKSPACE.md")
     ];
     for (const abs of workspaceArtifacts) {
-      if (await fs53.pathExists(abs)) {
-        log(`[dry-run] Would remove ${path77.relative(workspaceRoot, abs)}`);
+      if (await fs56.pathExists(abs)) {
+        log(`[dry-run] Would remove ${path78.relative(workspaceRoot, abs)}`);
       }
     }
-    if (!await fs53.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
-      const claudeMd = await readText(path77.join(workspaceRoot, "CLAUDE.md"));
+    if (!await fs56.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
+      const claudeMd = await readText(path78.join(workspaceRoot, "CLAUDE.md"));
       if (claudeMd?.includes(WORKSPACE_BLOCK_BEGIN) || claudeMd && hasLegacyWorkspaceBlock(claudeMd)) {
         log("[dry-run] Would remove the workspace haus import block from CLAUDE.md");
       }
@@ -13884,7 +14486,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   let anyRepoFailed = false;
   for (const repo of config.repos) {
-    const repoRoot = path77.resolve(workspaceRoot, repo.path);
+    const repoRoot = path78.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -13904,29 +14506,29 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
       continue;
     }
-    if (await fs53.pathExists(abs)) {
-      await fs53.remove(abs);
+    if (await fs56.pathExists(abs)) {
+      await fs56.remove(abs);
       log(`Removed ${entry.path} (linked ${entry.type} from ${entry.repo})`);
     }
   }
   for (const rel of WORKSPACE_AGGREGATE_FILES) {
     const abs = hausPath(workspaceRoot, rel);
-    if (await fs53.pathExists(abs)) {
-      await fs53.remove(abs);
-      log(`Removed ${path77.relative(workspaceRoot, abs)}`);
+    if (await fs56.pathExists(abs)) {
+      await fs56.remove(abs);
+      log(`Removed ${path78.relative(workspaceRoot, abs)}`);
     }
   }
   const manifestFile = manifestPath(workspaceRoot);
-  if (await fs53.pathExists(manifestFile)) {
-    await fs53.remove(manifestFile);
-    log(`Removed ${path77.relative(workspaceRoot, manifestFile)}`);
+  if (await fs56.pathExists(manifestFile)) {
+    await fs56.remove(manifestFile);
+    log(`Removed ${path78.relative(workspaceRoot, manifestFile)}`);
   }
   const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
-  if (await fs53.pathExists(workspaceMdPath)) {
-    await fs53.remove(workspaceMdPath);
-    log(`Removed ${path77.relative(workspaceRoot, workspaceMdPath)}`);
+  if (await fs56.pathExists(workspaceMdPath)) {
+    await fs56.remove(workspaceMdPath);
+    log(`Removed ${path78.relative(workspaceRoot, workspaceMdPath)}`);
   } else {
-    const claudeMdPath = path77.join(workspaceRoot, "CLAUDE.md");
+    const claudeMdPath = path78.join(workspaceRoot, "CLAUDE.md");
     if (existsSync10(claudeMdPath)) {
       const prev = await readText(claudeMdPath);
       if (prev?.includes(WORKSPACE_BLOCK_BEGIN)) {
@@ -13935,19 +14537,19 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
           end: WORKSPACE_BLOCK_END
         });
         if (next.length === 0) {
-          await fs53.remove(claudeMdPath);
+          await fs56.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the workspace haus import block).");
         } else {
-          await fs53.writeFile(claudeMdPath, next, "utf8");
+          await fs56.writeFile(claudeMdPath, next, "utf8");
           log("Removed haus import block from CLAUDE.md (user content preserved).");
         }
       } else if (prev && hasLegacyWorkspaceBlock(prev)) {
         const next = stripHausBlock(prev, { begin: BLOCK_BEGIN, end: BLOCK_END });
         if (next.length === 0) {
-          await fs53.remove(claudeMdPath);
+          await fs56.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the pre-upgrade workspace haus import block).");
         } else {
-          await fs53.writeFile(claudeMdPath, next, "utf8");
+          await fs56.writeFile(claudeMdPath, next, "utf8");
           log(
             "Removed pre-upgrade workspace haus import block from CLAUDE.md (user content preserved)."
           );
@@ -13995,7 +14597,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path78.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path79.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -14017,7 +14619,7 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path78.resolve(workspaceRoot, repo.path);
+    const repoRoot = path79.resolve(workspaceRoot, repo.path);
     try {
       if (!existsSync11(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
@@ -14065,7 +14667,8 @@ async function runWorkspace(action, options = {}) {
         dryRun: options.dryRun,
         json: options.json,
         continueOnError: options.continueOnError,
-        only: normalizeOnly(options.only)
+        only: normalizeOnly(options.only),
+        allowEmptyCache: options.allowEmptyCache
       });
       return;
     case "doctor":
@@ -14085,7 +14688,7 @@ init_logger();
 init_paths();
 function cliVersion() {
   try {
-    const pkgPath = path79.join(packageRoot(), "package.json");
+    const pkgPath = path80.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -14095,7 +14698,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path79.join(packageRoot(), "package.json");
+    const pkgPath = path80.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -14109,6 +14712,9 @@ function validateRuntimeNodeVersion() {
 }
 validateRuntimeNodeVersion();
 program.name("haus").description("Haus AI workflow CLI").version(cliVersion());
+program.option("--offline", "Make no network calls; use cached or bundled catalog content only").hook("preAction", (thisCommand) => {
+  setOfflineFlag(Boolean(thisCommand.opts()["offline"]));
+});
 program.command("scan").description(
   "Scan the repo for roles, dependencies, and package manager; writes context-map.json"
 ).option("--json").action(runScan);
@@ -14125,7 +14731,7 @@ program.command("apply").description("Write recommended catalog items and core C
   "Install exactly these recommended item ids non-interactively (skill backend; space- or comma-separated)"
 ).option(
   "--allow-empty-cache",
-  "Apply core files only when catalog cache is empty (skip catalog items without error)"
+  "Proceed when no catalog item has installable content: write core files and skip the catalog items. Still exits 1 if none installed (ADR-0060)"
 ).option(
   "--refill-config",
   "Fill still-blank fields in an existing workflow-config.md without touching edited ones"
@@ -14159,6 +14765,9 @@ program.command("explain-recommendation").description("Print a per-item breakdow
 program.command("init").description("Full setup: scan, recommend, and optionally apply Claude files (safe to re-run)").option("--dry-run", "Preview the `.claude/` write; scan artifacts are still written").option("--json", "Emit one JSON envelope on stdout (requires --dry-run)").option(
   "--force",
   "Write recommendation.json/haus.lock.json even when zero catalog items matched at all"
+).option(
+  "--allow-empty-cache",
+  "Proceed when no catalog item has installable content: write core files and skip the catalog items. Still exits 1 if none installed (ADR-0060)"
 ).action(runInit);
 program.command("new").description("Create a new project from an allowed Haus stack, push it to GitHub, and run init").argument("[stack]", "Stack id (omit to pick interactively; see --list)").argument("[name]", "Project directory and repo name").option("--list", "Print the allowed stacks and exit").option("--org <org>", "GitHub org to create the repo in (default: personal account)").option("--public", "Create the GitHub repo public").option("--private", "Create the GitHub repo private (default)").option("--no-github", "Skip GitHub repo creation and push").option("--pm <pm>", "Package manager: yarn | npm | pnpm", "yarn").option("-y, --yes", "Skip confirmations (non-interactive)").option("--dry-run", "Print the full plan without executing anything").option("--json", "Emit a machine-readable result document").action(runNew);
 program.command("clone").description("Clone a single git repository by URL").argument("<url>", "Git URL to clone").argument("[dir]", "Target directory (default: repo name derived from the URL)").option("--dry-run", "Print what would happen without cloning").action(
@@ -14167,6 +14776,12 @@ program.command("clone").description("Clone a single git repository by URL").arg
 program.command("rescan").description("Re-scan the project, refresh recommendations, and update scan artifacts").option("--dry-run", "Report what would change without writing scan artifacts").action((opts) => runRescan({ dryRun: opts.dryRun }));
 program.command("catalog-audit").description("Check the bundled catalog manifest for unsupported or forbidden stacks").action(runCatalogAudit);
 program.command("validate-catalog").description("Validate a catalog manifest at an explicit path").argument("[manifest]").action(runValidateCatalog);
+var catalog = program.command("catalog").description("Catalog cache maintenance");
+var catalogBundle = catalog.command("bundle").description("Move catalog content between machines (for air-gapped installs)");
+catalogBundle.command("export").description("Write the populated catalog cache to a portable archive").requiredOption("--out <file>", "Destination .tgz path").action((opts) => runBundleExport({ out: opts.out }));
+catalogBundle.command("import <file>").description("Unpack a catalog bundle into the local cache (validated like a network sync)").option("--dry-run", "Print what would be imported without writing anything").action(
+  (file, opts) => runBundleImport(file, { dryRun: opts.dryRun })
+);
 program.command("update").description("Sync the remote catalog cache, refresh the lockfile, and check for CLI updates").option("--check").option("--fast", "With --check, skip per-item content hashing (cheap count+ref only)").option("--from-hook", "Emit JSON for the Claude Code SessionStart hook (silent if up to date)").action(runUpdate);
 program.command("ci-gate").description(
   "Aggregate `doctor` + `decisions check` + `update --check --fast` into one pass/fail gate for CI. Uses the fast/cheap update-check tier (no per-item content hashing) to keep CI runs quick \u2014 run `haus update --check` directly for the fully-hashed tier. Each constituent command remains independently runnable with its own unchanged exit-code contract."
@@ -14195,7 +14810,10 @@ var workspace = program.command("workspace").description("Multi-repo workspace c
 workspace.command("init").option("-y, --yes", "Skip confirmation when haus.workspace.yaml already exists").action((opts) => runWorkspace("init", opts));
 workspace.command("discover").description("Auto-find member repos and write/merge haus.workspace.yaml").option("--write", "Persist haus.workspace.yaml (default previews only)").option("--json", "Output the discovered repos and proposed config as JSON").option("--max-depth <n>", "Max directory depth to traverse (default 3)").option("--client <name>", "Set the workspace client name").action((opts) => runWorkspace("discover", opts));
 workspace.command("scan").description("Aggregate a cross-repo summary from a fast scan of each repo").option("--json", "Output the written artifact paths as JSON").action((opts) => runWorkspace("scan", opts));
-workspace.command("setup").description("Per-repo setup loop + workspace layer + manifest").option("--write", "Apply changes (default previews only)").option("--dry-run", "Preview changes without writing").option("--json", "Emit machine-readable per-repo output").option("--continue-on-error", "Keep going past a failed repo (default fail-fast)").option("--only <names>", "Restrict to comma-separated repo names").action((opts) => runWorkspace("setup", opts));
+workspace.command("setup").description("Per-repo setup loop + workspace layer + manifest").option("--write", "Apply changes (default previews only)").option("--dry-run", "Preview changes without writing").option("--json", "Emit machine-readable per-repo output").option("--continue-on-error", "Keep going past a failed repo (default fail-fast)").option("--only <names>", "Restrict to comma-separated repo names").option(
+  "--allow-empty-cache",
+  "Proceed when a member repo has no installable catalog content: write core files and skip catalog items for that repo. That repo is still recorded failed if nothing installed (ADR-0060)"
+).action((opts) => runWorkspace("setup", opts));
 workspace.command("doctor").description("Report workspace drift against the manifest").option("--json", "Output the manifest and drift array as JSON").action((opts) => runWorkspace("doctor", opts));
 workspace.command("undo").description("Revert haus setup for every configured repo, plus workspace-root artifacts").option("-y, --yes", "Skip confirmation").option("--dry-run", "Print what would be removed without deleting anything").action((opts) => runWorkspace("undo", opts));
 workspace.command("link-context").description(