@haus-tech/haus-workflow 4.9.0 → 5.0.0

package/dist/cli.js

@@ -1998,7 +1998,7 @@ var init_sync = __esm({
 // src/cli.ts
 init_offline();
 import { readFileSync as readFileSync5 } from "node:fs";
-import path89 from "node:path";
+import path90 from "node:path";
 import { Command, Option } from "commander";
 
 // src/commands/apply.ts
@@ -2787,41 +2787,12 @@ function parseHausManagedHeader(line2) {
 }
 
 // src/claude/superpowers-install.ts
-init_constants();
 import path14 from "node:path";
 import fg2 from "fast-glob";
 import fs10 from "fs-extra";
 init_logger();
-init_paths();
-var SUPERPOWERS_ORIGIN_SOURCE_ID = "superpowers-pcvelz";
-var SUPERPOWERS_SHARED_INSTALL_REL = ".claude/skills/shared";
-var PATH_REWRITES = [
-  ["skills/shared/", ".claude/skills/shared/"]
-];
-var PREFIX_REWRITES = ["superpowers-extended-cc:"];
 var SKILL_DEP_ARTIFACTS = ["node_modules/**"];
 var SKILL_DEP_ARTIFACT_DIRS = /* @__PURE__ */ new Set(["node_modules"]);
-function rewriteSuperpowersMarkdown(text) {
-  let out = text;
-  for (const [from, to] of PATH_REWRITES) {
-    out = out.split(from).join(to);
-  }
-  for (const prefix of PREFIX_REWRITES) {
-    out = out.split(prefix).join("");
-  }
-  return out;
-}
-async function rewriteMarkdownTree(dir) {
-  const files = await fg2("**/*.md", { cwd: dir, onlyFiles: true, dot: true });
-  for (const rel of files) {
-    const abs = path14.join(dir, rel);
-    const text = await fs10.readFile(abs, "utf8");
-    const rewritten = rewriteSuperpowersMarkdown(text);
-    if (rewritten !== text) {
-      await fs10.writeFile(abs, rewritten, "utf8");
-    }
-  }
-}
 async function extraDestFiles(sourcePath, destination) {
   const [sourceFiles, destFiles] = await Promise.all([
     fg2("**/*", { cwd: sourcePath, onlyFiles: true, dot: true, ignore: [...SKILL_DEP_ARTIFACTS] }),
@@ -2832,8 +2803,7 @@ async function extraDestFiles(sourcePath, destination) {
 }
 var SKILL_ENTRY_FILE = "SKILL.md";
 function installedSkillText(text, opts) {
-  const rewritten = opts.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID ? rewriteSuperpowersMarkdown(text) : text;
-  return opts.description ? rewriteSkillDescription(rewritten, opts.description) : rewritten;
+  return opts.description ? rewriteSkillDescription(text, opts.description) : text;
 }
 async function previewInstalledSkill(srcFile, opts) {
   const text = await readRewritableText(srcFile);
@@ -2870,30 +2840,8 @@ async function installCatalogSkill(sourcePath, destination, opts) {
     }
   }
   await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
-  if (opts.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID) {
-    await rewriteMarkdownTree(destination);
-  }
   if (opts.description) await composeInstalledDescription(destination, opts.description);
 }
-async function installSuperpowersShared(contentRoot, projectRoot, dryRun) {
-  const source = path14.join(contentRoot, SUPERPOWERS_SHARED_CATALOG_REL);
-  if (!await fs10.pathExists(source)) return null;
-  const destination = claudePath(projectRoot, "skills", "shared");
-  if (dryRun) return path14.relative(projectRoot, destination);
-  await fs10.ensureDir(path14.dirname(destination));
-  if (await fs10.pathExists(destination)) {
-    const extra = await extraDestFiles(source, destination);
-    if (extra.length > 0) {
-      warn(
-        `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
-      );
-    }
-    await fs10.remove(destination);
-  }
-  await fs10.copy(source, destination, { overwrite: true, errorOnExist: false });
-  await rewriteMarkdownTree(destination);
-  return path14.relative(projectRoot, destination);
-}
 
 // src/update/hash-installed.ts
 init_fs();
@@ -3103,6 +3051,15 @@ async function recordManifestPlugins(plugins) {
   for (const plugin of plugins) byId.set(plugin.id, plugin);
   await writeManifest({ ...manifest, plugins: [...byId.values()] });
 }
+async function pruneManifestPlugins(pluginKeys) {
+  if (pluginKeys.length === 0) return;
+  const manifest = await readManifest();
+  if (!manifest || !manifest.plugins || manifest.plugins.length === 0) return;
+  const drop = new Set(pluginKeys);
+  const kept = manifest.plugins.filter((p) => !drop.has(`${p.plugin}@${p.marketplace}`));
+  if (kept.length === manifest.plugins.length) return;
+  await writeManifest({ ...manifest, plugins: kept });
+}
 function buildManifest(source, files, hooks, plugins) {
   return {
     _schema: MANIFEST_SCHEMA,
@@ -3437,8 +3394,8 @@ function buildDenyRules() {
     if (RUNTIME_ONLY_DENY_COMMANDS.includes(command)) continue;
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path90 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path90) ? `${path90}/**` : path90;
+  for (const path91 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path91) ? `${path91}/**` : path91;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -3870,6 +3827,7 @@ async function verifyProjectSettingsHooksContract(root) {
 init_logger();
 import path20 from "node:path";
 import fs17 from "fs-extra";
+import YAML from "yaml";
 var CI_GATE_WORKFLOW_REL = path20.join(".github", "workflows", "haus-gate.yml");
 var WORKFLOW = `# Written by \`haus init\`. Yours to edit \u2014 haus will not rewrite this file.
 #
@@ -3898,12 +3856,21 @@ jobs:
           node-version: '22'
       - name: Install haus
         run: npm install -g @haus-tech/haus-workflow@latest
+      # \`.haus-workflow/recommendation.json\` is machine-local and gitignored
+      # (ADR-0025), so it is absent on every CI clone \u2014 and without it \`doctor\`
+      # cannot tell "the catalog gates this agent out of your stack" from "you are
+      # missing an install", so it keeps the stricter reading and fails the gate over
+      # upstream prose you cannot act on. Computing one first is what makes the
+      # severity rules in ADR-0070/ADR-0095 work here. Writes only gitignored files.
+      - name: Compute a recommendation for this stack
+        run: haus recommend
       - name: haus ci-gate
         run: haus ci-gate
 `;
 async function writeCiGateWorkflow(root, dryRun, quiet = false) {
   const dest = path20.join(root, CI_GATE_WORKFLOW_REL);
   if (await fs17.pathExists(dest)) return void 0;
+  if (await projectRunsCiGate(root)) return void 0;
   if (dryRun) {
     if (!quiet) log(`Would write ${CI_GATE_WORKFLOW_REL} (CI gate: haus ci-gate on every PR)`);
     return dest;
@@ -3913,6 +3880,20 @@ async function writeCiGateWorkflow(root, dryRun, quiet = false) {
   if (!quiet) log(`Wrote ${CI_GATE_WORKFLOW_REL} \u2014 runs \`haus ci-gate\` on every pull request`);
   return dest;
 }
+var CI_GATE_COMMAND = /\bci-gate\b/;
+function runScripts(node, found = []) {
+  if (Array.isArray(node)) {
+    for (const item of node) runScripts(item, found);
+    return found;
+  }
+  if (node && typeof node === "object") {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "run" && typeof value === "string") found.push(value);
+      else runScripts(value, found);
+    }
+  }
+  return found;
+}
 async function projectRunsCiGate(root) {
   const dir = path20.join(root, ".github", "workflows");
   let entries;
@@ -3925,7 +3906,7 @@ async function projectRunsCiGate(root) {
     if (!/\.ya?ml$/i.test(entry)) continue;
     try {
       const text = await fs17.readFile(path20.join(dir, entry), "utf8");
-      if (/\bci-gate\b/.test(text)) return true;
+      if (runScripts(YAML.parse(text)).some((script) => CI_GATE_COMMAND.test(script))) return true;
     } catch {
     }
   }
@@ -4667,7 +4648,6 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   }
   const catalogItems = [...catalogItemsById.values()];
   let curatedReviewStatusSkips = 0;
-  let superpowersSharedInstalled = false;
   const projectPackageManager = detectPackageManager(
     root,
     (await readJson(path26.join(root, "package.json")))?.packageManager
@@ -4814,14 +4794,6 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       }
       files.push(destination);
       const relPaths = [path26.relative(root, destination)];
-      if (!superpowersSharedInstalled && manifestItem.originSourceId === SUPERPOWERS_ORIGIN_SOURCE_ID && item.type === "skill") {
-        const sharedRel = await installSuperpowersShared(contentRoot, root, dryRun);
-        if (sharedRel) {
-          superpowersSharedInstalled = true;
-          relPaths.push(sharedRel);
-          files.push(path26.join(root, sharedRel));
-        }
-      }
       const current = installedPathsByItem.get(item.id) ?? [];
       installedPathsByItem.set(item.id, [...current, ...relPaths]);
       installedIds.add(item.id);
@@ -5014,6 +4986,7 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
     }
   }
 }
+var LEGACY_SUPERPOWERS_SHARED_REL_PATH = ".claude/skills/shared";
 async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activePluginIds = []) {
   const say = quiet ? () => {
   } : log;
@@ -5067,7 +5040,7 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
       continue;
     }
     const removable = superseded ? existing.filter(({ rel }) => {
-      const isShared = rel.split(path26.sep).join("/") === SUPERPOWERS_SHARED_INSTALL_REL;
+      const isShared = rel.split(path26.sep).join("/") === LEGACY_SUPERPOWERS_SHARED_REL_PATH;
       if (isShared && keepShared) {
         say(
           `Keeping ${displayPath(root, path26.join(root, rel))} \u2014 a locally-edited superpowers skill still uses it`
@@ -5326,12 +5299,39 @@ init_logger();
 var DEFAULT_GLOBAL_PLUGINS = [
   {
     id: "superpowers",
+    plugin: "superpowers",
+    marketplace: "superpowers-dev",
+    url: "https://github.com/obra/superpowers.git",
+    ref: "v6.3.0"
+  }
+];
+var FORMER_GLOBAL_PLUGINS = [
+  {
+    id: "superpowers-extended-cc",
     plugin: "superpowers-extended-cc",
     marketplace: "superpowers-extended-cc-marketplace",
     url: "https://github.com/pcvelz/superpowers.git",
     ref: "v6.4.0"
   }
 ];
+function planStalePluginRemovals(desired, candidates, state) {
+  if (!state.available) return [];
+  const desiredIds = new Set(desired.map(pluginId));
+  const desiredMarketplaces = new Set(desired.map((pin) => pin.marketplace));
+  const seen = /* @__PURE__ */ new Set();
+  const stale = [];
+  for (const candidate of candidates) {
+    const id = pluginId(candidate);
+    if (desiredIds.has(id) || seen.has(id)) continue;
+    seen.add(id);
+    const installedAtManagedScope = state.installed.some(
+      (p) => p.id === id && (p.scope ?? MANAGED_SCOPE) === MANAGED_SCOPE
+    );
+    const marketplaceLeftover = !desiredMarketplaces.has(candidate.marketplace) && state.marketplaces.some((m) => m.name === candidate.marketplace);
+    if (installedAtManagedScope || marketplaceLeftover) stale.push(candidate);
+  }
+  return stale;
+}
 var MANAGED_SCOPE = "user";
 function pluginId(pin) {
   return `${pin.plugin}@${pin.marketplace}`;
@@ -5712,7 +5712,7 @@ async function removeGlobalPlugins(plugins, deps = {}) {
   const exec = deps.exec ?? realExec;
   const warn2 = deps.warn ?? warn;
   const log2 = deps.log ?? log;
-  const result = { removed: [], failed: [], unavailable: false };
+  const result = { removed: [], failed: [], unavailable: false, converged: [] };
   if (plugins.length === 0) return result;
   if (globalPluginMutationsDisabled() && deps.exec === void 0) {
     return { ...result, unavailable: true };
@@ -5725,15 +5725,28 @@ async function removeGlobalPlugins(plugins, deps = {}) {
   }
   const scopeKey = (id, scope) => `${id}@@${scope ?? "user"}`;
   const stillInstalled = new Set(state.installed.map((p) => scopeKey(p.id, p.scope)));
+  const marketplaceNeedsRemoval = (pin) => {
+    const marketplaceStillConfigured = state.marketplaces.some((m) => m.name === pin.marketplace);
+    const othersFromMarketplace = [...stillInstalled].some(
+      (key) => key.split("@@")[0]?.endsWith(`@${pin.marketplace}`)
+    );
+    return marketplaceStillConfigured && !othersFromMarketplace;
+  };
   for (const pin of plugins) {
     const id = pluginId(pin);
     const managedKey = scopeKey(id, "user");
+    const wasInstalledAtManagedScope = stillInstalled.has(managedKey);
     if (deps.dryRun) {
-      if (stillInstalled.has(managedKey))
+      if (wasInstalledAtManagedScope) {
         log2(`[dry-run] would remove global plugin ${pin.id} (${id})`);
+        stillInstalled.delete(managedKey);
+      }
+      if (marketplaceNeedsRemoval(pin)) {
+        log2(`[dry-run] would remove marketplace ${pin.marketplace}`);
+      }
       continue;
     }
-    if (stillInstalled.has(managedKey)) {
+    if (wasInstalledAtManagedScope) {
       const uninstalled = await exec(["plugin", "uninstall", id, "--scope", "user"]);
       if (uninstalled.exitCode !== 0) {
         result.failed.push(pin.id);
@@ -5745,21 +5758,60 @@ async function removeGlobalPlugins(plugins, deps = {}) {
       stillInstalled.delete(managedKey);
       result.removed.push(pin.id);
     }
-    const marketplaceStillConfigured = state.marketplaces.some((m) => m.name === pin.marketplace);
-    const othersFromMarketplace = [...stillInstalled].some(
-      (key) => key.split("@@")[0]?.endsWith(`@${pin.marketplace}`)
-    );
-    if (marketplaceStillConfigured && !othersFromMarketplace) {
+    let marketplaceRemovalFailed = false;
+    if (marketplaceNeedsRemoval(pin)) {
       const removedMarket = await exec(["plugin", "marketplace", "remove", pin.marketplace]);
       if (removedMarket.exitCode !== 0) {
+        marketplaceRemovalFailed = true;
         warn2(
           `Could not remove marketplace ${pin.marketplace}: ${removedMarket.stderr.trim() || `exit ${removedMarket.exitCode}`}`
         );
       }
     }
+    if (!wasInstalledAtManagedScope && !marketplaceRemovalFailed) {
+      result.converged.push(pin.id);
+    }
   }
   return result;
 }
+async function cleanupStaleGlobalPlugins(desired, deps = {}) {
+  const none = { planned: [], removed: [], failed: [], unavailable: false };
+  if (globalPluginMutationsDisabled() && deps.exec === void 0) {
+    return { ...none, unavailable: true };
+  }
+  const state = await probePluginEnv(deps);
+  if (!state.available) return { ...none, unavailable: true };
+  const manifest = await readManifest();
+  const recorded = (manifest?.plugins ?? []).filter(isValidPin);
+  const protectedPins = [...desired, ...DEFAULT_GLOBAL_PLUGINS];
+  const planned = planStalePluginRemovals(
+    protectedPins,
+    [...recorded, ...FORMER_GLOBAL_PLUGINS],
+    state
+  );
+  if (planned.length === 0) return none;
+  const removal = await removeGlobalPlugins(planned, deps);
+  const removedPins = planned.filter((pin) => removal.removed.includes(pin.id));
+  const convergedPins = planned.filter((pin) => removal.converged.includes(pin.id));
+  if (!deps.dryRun) {
+    const toPrune = [...removedPins, ...convergedPins];
+    if (toPrune.length > 0) {
+      await pruneManifestPlugins(toPrune.map((pin) => pluginId(pin)));
+    }
+    if (removedPins.length > 0) {
+      const log2 = deps.log ?? log;
+      log2(
+        `Removed stale global plugin(s): ${removedPins.map((pin) => pluginId(pin)).join(", ")}. Restart Claude Code to unload them.`
+      );
+    }
+  }
+  return {
+    planned,
+    removed: removal.removed,
+    failed: removal.failed,
+    unavailable: removal.unavailable
+  };
+}
 
 // src/refs/fetch-refs.ts
 import path30 from "node:path";
@@ -7080,8 +7132,34 @@ import path34 from "node:path";
 import fg4 from "fast-glob";
 import fs33 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 escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildKnownNamespacePattern(names) {
+  if (names.length === 0) return null;
+  const alternation = names.map(escapeRegExp2).join("|");
+  return new RegExp(`\\b(${alternation}):([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\\b(?!:\\/\\/)`, "g");
+}
+function collectReferenceMatches(line2, knownPattern) {
+  const seenSpans = /* @__PURE__ */ new Set();
+  const matches = [];
+  const collectFrom = (regex) => {
+    for (const match of line2.matchAll(regex)) {
+      const [reference, namespace, bareName] = match;
+      if (!reference || !namespace || !bareName || match.index === void 0) continue;
+      const span = `${match.index}:${reference.length}`;
+      if (seenSpans.has(span)) continue;
+      seenSpans.add(span);
+      matches.push({ reference, namespace, bareName, index: match.index });
+    }
+  };
+  collectFrom(REFERENCE_PATTERN);
+  if (knownPattern) collectFrom(knownPattern);
+  return matches.sort((a, b) => a.index - b.index);
+}
+var FENCED_BLOCK = /(```|~~~)[\s\S]*?\1/g;
 function stripFencedCodeBlocks(text) {
-  return text.replace(/```[\s\S]*?```/g, (block) => block.replace(/[^\n]/g, " "));
+  return text.replace(FENCED_BLOCK, (block) => block.replace(/[^\n]/g, " "));
 }
 var INLINE_CODE_SPAN = /(`+)(?!`)[\s\S]*?\1/g;
 function inlineCodeSpanRanges(line2) {
@@ -7093,18 +7171,19 @@ function inlineCodeSpanRanges(line2) {
 }
 async function findUnresolvedSkillReferences(root, options = {}) {
   const resolvableNamespaces = new Set(options.pluginNamespaces ?? []);
+  const knownNamespacePattern = buildKnownNamespacePattern(options.knownPluginNamespaces ?? []);
   const installedSkillNames = await readInstalledSkillNames(root);
   const issues = [];
   for (const { file, lines } of await readScannedMarkdown(root)) {
     lines.forEach((line2, idx) => {
       const codeSpans = inlineCodeSpanRanges(line2);
-      for (const match of line2.matchAll(REFERENCE_PATTERN)) {
-        const [reference, namespace, bareName] = match;
+      for (const { reference, namespace, bareName, index } of collectReferenceMatches(
+        line2,
+        knownNamespacePattern
+      )) {
         if (!reference || !bareName) continue;
         if (namespace && resolvableNamespaces.has(namespace)) continue;
-        const inCodeSpan = codeSpans.some(
-          ([start, end]) => match.index >= start && match.index < end
-        );
+        const inCodeSpan = codeSpans.some(([start, end]) => index >= start && index < end);
         if (inCodeSpan && !installedSkillNames.has(bareName)) continue;
         issues.push({
           file,
@@ -7118,37 +7197,107 @@ async function findUnresolvedSkillReferences(root, options = {}) {
   }
   return issues;
 }
-var BOLD_AGENT_PATTERN = /\*\*([a-z][a-z0-9]*(?:-[a-z0-9]+)+)\*\*/g;
+var BOLD_SPAN = /\*\*([^*\n]+)\*\*/g;
+var BARE_NAME = /^[a-z0-9][a-z0-9-]{2,}$/;
+var KEBAB_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/;
 var AGENT_WORD = /\bagents?\b/i;
+var ITEMS_HEADING = /\b(?:skills?|agents?)\b/i;
+var LIST_ITEM = /^(\s*(?:[-*+]|\d+[.)])\s+)(.*)$/;
+var LIST_LABEL = /^[A-Za-z][A-Za-z /]{0,24}:\s*/;
+var KEYWORD_BEFORE = /(?:sub)?(?:skills?|agents?)\s*[:=-]*\s*$/i;
+var KEYWORD_AFTER = /^\s+(?:[A-Za-z]+\s+)?(?:sub)?(?:skills?|agents?)\b/i;
+var ROUTER_BEFORE = /\b(?:routes?|routing|delegates?|dispatch(?:es)?|hands? off)\s*(?:to|→|->|:)?\s*$/i;
+var RUN_SEPARATOR = /^\s*(?:\([^)\n]*\))?\s*(?:,|;|\/|\band\b|\bor\b|\bplus\b)\s*(?:the\s+)?$/i;
+var INLINE_KEYWORD_NAME = /^(?:sub)?(?:skills?|agents?)\s*[:=]\s*(\S+)$/i;
+var SUBAGENT = /subagent_type\s*=\s*["']([^"']+)["']/g;
+function isBareNameLike(name) {
+  return BARE_NAME.test(name);
+}
+function normalizeName(ref) {
+  return ref.split("#")[0].split("?")[0].trim().replace(/[.,;:!)\]]+$/, "");
+}
+function boldNameSpans(line2) {
+  const spans = [];
+  for (const match of line2.matchAll(BOLD_SPAN)) {
+    const text = match[1];
+    if (text && isBareNameLike(text)) {
+      spans.push({ text, start: match.index, end: match.index + match[0].length });
+    }
+  }
+  return spans;
+}
+function groupRuns(line2, spans) {
+  const runs = [];
+  for (const span of spans) {
+    const current = runs.at(-1);
+    const previous = current?.at(-1);
+    if (current && previous && RUN_SEPARATOR.test(line2.slice(previous.end, span.start))) {
+      current.push(span);
+    } else {
+      runs.push([span]);
+    }
+  }
+  return runs;
+}
 function isAgentContext(line2, nearestHeading) {
-  const outsideBold = line2.replace(BOLD_AGENT_PATTERN, " ");
-  return AGENT_WORD.test(outsideBold) || AGENT_WORD.test(nearestHeading);
+  let blanked = "";
+  let cursor = 0;
+  for (const span of boldNameSpans(line2)) {
+    blanked += line2.slice(cursor, span.start) + " ".repeat(span.end - span.start);
+    cursor = span.end;
+  }
+  blanked += line2.slice(cursor);
+  return AGENT_WORD.test(blanked) || AGENT_WORD.test(nearestHeading);
+}
+function extractNameReferences(lines, { knownNames = /* @__PURE__ */ new Set() } = {}) {
+  const out = [];
+  let nearestHeading = "";
+  lines.forEach((line2, idx) => {
+    if (/^#{1,6}\s/.test(line2)) nearestHeading = line2.replace(/^#{1,6}\s*/, "");
+    const lineNumber = idx + 1;
+    const codeSpans = inlineCodeSpanRanges(line2);
+    const inCodeSpan = (index) => codeSpans.some(([start, end]) => index >= start && index < end);
+    const listMatch = line2.match(LIST_ITEM);
+    const itemBody = listMatch?.[2]?.replace(LIST_LABEL, "");
+    const itemBodyStart = itemBody === void 0 ? -1 : line2.length - itemBody.length;
+    const underItemsHeading = ITEMS_HEADING.test(nearestHeading);
+    const looseContext = isAgentContext(line2, nearestHeading);
+    for (const run of groupRuns(line2, boldNameSpans(line2))) {
+      const before = line2.slice(0, run[0].start);
+      const after = line2.slice(run.at(-1).end);
+      const positional = KEYWORD_BEFORE.test(before) || ROUTER_BEFORE.test(before) || KEYWORD_AFTER.test(after) || // Two co-listed installed items make the run an item list. One is not enough:
+      // package names share basenames with skills.
+      run.filter((span) => knownNames.has(span.text)).length >= 2 || underItemsHeading && run[0].start === itemBodyStart;
+      for (const span of run) {
+        if (inCodeSpan(span.start)) continue;
+        if (!positional && !(KEBAB_NAME.test(span.text) && looseContext)) continue;
+        out.push({ line: lineNumber, name: span.text, kind: "bold" });
+      }
+    }
+    for (const [start, end] of codeSpans) {
+      const keyword = line2.slice(start, end).replace(/^`+|`+$/g, "").trim().match(INLINE_KEYWORD_NAME);
+      if (!keyword) continue;
+      const name = normalizeName(keyword[1]);
+      if (isBareNameLike(name)) out.push({ line: lineNumber, name, kind: "label" });
+    }
+    for (const match of line2.matchAll(SUBAGENT)) {
+      if (match[1]) out.push({ line: lineNumber, name: match[1], kind: "subagent" });
+    }
+  });
+  return out;
 }
 async function findUnresolvedAgentReferences(root, options = {}) {
   const installedAgentNames = await readInstalledAgentNames(root);
   const catalogAgentNames = new Set(options.catalogAgentNames ?? []);
   const issues = [];
+  const installedNames = /* @__PURE__ */ new Set([...installedAgentNames, ...await readInstalledSkillNames(root)]);
   for (const { file, lines } of await readScannedMarkdown(root)) {
-    let nearestHeading = "";
-    lines.forEach((line2, idx) => {
-      if (/^#{1,6}\s/.test(line2)) nearestHeading = line2.replace(/^#{1,6}\s*/, "");
-      if (!isAgentContext(line2, nearestHeading)) return;
-      const codeSpans = inlineCodeSpanRanges(line2);
-      for (const match of line2.matchAll(BOLD_AGENT_PATTERN)) {
-        const agentName = match[1];
-        if (!agentName || installedAgentNames.has(agentName)) continue;
-        const inCodeSpan = codeSpans.some(
-          ([start, end]) => match.index >= start && match.index < end
-        );
-        if (inCodeSpan) continue;
-        issues.push({
-          file,
-          line: idx + 1,
-          agentName,
-          inCatalog: catalogAgentNames.has(agentName)
-        });
-      }
-    });
+    for (const { line: line2, name, kind } of extractNameReferences(lines, {
+      knownNames: installedNames
+    })) {
+      if (installedNames.has(name)) continue;
+      issues.push({ file, line: line2, agentName: name, kind, inCatalog: catalogAgentNames.has(name) });
+    }
   }
   return issues;
 }
@@ -8005,13 +8154,13 @@ import fs39 from "fs-extra";
 // src/commands/workspace/config.ts
 init_fs();
 import path41 from "node:path";
-import YAML from "yaml";
+import YAML2 from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
   if (!text) return void 0;
   let parsed;
   try {
-    parsed = YAML.parse(text);
+    parsed = YAML2.parse(text);
   } catch {
     return void 0;
   }
@@ -8496,7 +8645,7 @@ async function buildContentBlob(root, files) {
 // src/scanner/workspace-packages.ts
 import path45 from "node:path";
 import fg5 from "fast-glob";
-import YAML2 from "yaml";
+import YAML3 from "yaml";
 init_fs();
 var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
 var MAX_WORKSPACE_MEMBERS = 200;
@@ -8518,7 +8667,7 @@ function workspaceGlobsFromPackageJson(pkg) {
 }
 function workspaceGlobsFromPnpmYaml(text) {
   try {
-    const doc = YAML2.parse(text);
+    const doc = YAML3.parse(text);
     if (!isRecord(doc)) return [];
     return stringEntries(doc.packages);
   } catch {
@@ -8830,9 +8979,7 @@ async function runDoctor(options) {
     return;
   }
   const context = await readContextOrScan(root);
-  const recommendation = await readJson(
-    hausPath(root, "recommendation.json")
-  );
+  const recommendation = await readJson(hausPath(root, "recommendation.json"));
   const detail = [];
   const attention = [];
   const suggestions = [];
@@ -9142,8 +9289,16 @@ async function runDoctor(options) {
       );
     }
   }
+  const knownNamespaces = [
+    .../* @__PURE__ */ new Set([
+      ...pluginPins.map((pin) => pin.plugin),
+      ...DEFAULT_GLOBAL_PLUGINS.map((pin) => pin.plugin),
+      ...FORMER_GLOBAL_PLUGINS.map((pin) => pin.plugin)
+    ])
+  ];
   const skillRefIssues = await findUnresolvedSkillReferences(root, {
-    pluginNamespaces: activeNamespaces
+    pluginNamespaces: activeNamespaces,
+    knownPluginNamespaces: knownNamespaces
   });
   if (skillRefIssues.length > 0) {
     const prefixBug = skillRefIssues.filter((i) => i.bareInstalled);
@@ -9165,27 +9320,83 @@ async function runDoctor(options) {
       );
     }
   }
-  const agentCatalogNames = catalogItems === null ? [] : catalogItems.filter((item) => item.type === "agent").map((item) => installTargetFor(item)).flatMap((target) => target.ok ? [path48.basename(target.relPath, ".md")] : []);
+  const recommendedEntries = recommendation && Array.isArray(recommendation.recommended) ? recommendation.recommended : null;
+  const recommendedIds = new Set(
+    (recommendedEntries ?? []).map((entry) => entry.id).filter((id) => typeof id === "string")
+  );
+  const eligibilityKnown = recommendedEntries !== null;
+  const catalogAgents = catalogItems === null ? [] : catalogItems.flatMap((item) => {
+    if (item.type !== "agent") return [];
+    const target = installTargetFor(item);
+    return target.ok ? [{ id: item.id, name: path48.basename(target.relPath, ".md") }] : [];
+  });
+  const STACK_GATE_SKIP_CODES = /* @__PURE__ */ new Set([
+    "requires-any-unsatisfied",
+    "no-role-stack-match",
+    "required-role-missing"
+  ]);
+  const skippedEntries = Array.isArray(recommendation?.skipped) ? recommendation.skipped : [];
+  const stackGatedIds = /* @__PURE__ */ new Map();
+  for (const entry of skippedEntries) {
+    if (typeof entry.id !== "string" || !Array.isArray(entry.skipReasons)) continue;
+    for (const reason of entry.skipReasons) {
+      if (typeof reason?.code !== "string" || !STACK_GATE_SKIP_CODES.has(reason.code)) continue;
+      if (!stackGatedIds.has(entry.id)) {
+        stackGatedIds.set(entry.id, typeof reason.signal === "string" ? reason.signal : "");
+      }
+    }
+  }
+  const gatedOutAgentSignals = /* @__PURE__ */ new Map();
+  for (const agent of catalogAgents) {
+    if (recommendedIds.has(agent.id)) continue;
+    const signal = stackGatedIds.get(agent.id);
+    if (signal !== void 0) gatedOutAgentSignals.set(agent.name, signal);
+  }
   const agentRefIssues = await findUnresolvedAgentReferences(root, {
-    catalogAgentNames: agentCatalogNames
+    catalogAgentNames: catalogAgents.map((agent) => agent.name)
   });
   if (agentRefIssues.length > 0) {
     const describeAgent = (i) => `${i.file}:${i.line} "${i.agentName}"`;
-    const installable = agentRefIssues.filter((i) => i.inCatalog);
+    const referent = (group) => {
+      const kinds = new Set(group.map((i) => i.kind));
+      if (kinds.size === 1 && kinds.has("label")) return "a skill";
+      return kinds.has("label") ? "an agent or skill" : "an agent";
+    };
+    const routedTo = (group, names) => {
+      const list = names.join(", ");
+      const kinds = new Set(group.map((i) => i.kind));
+      if (kinds.size === 1 && kinds.has("label")) return `hand work to the skill ${list}`;
+      return kinds.has("label") ? `point at ${list}` : `send agents after ${list}`;
+    };
+    const stackGatedHere = (i) => eligibilityKnown && gatedOutAgentSignals.has(i.agentName);
+    const installable = agentRefIssues.filter((i) => i.inCatalog && !stackGatedHere(i));
+    const gatedOut = agentRefIssues.filter((i) => i.inCatalog && stackGatedHere(i));
     const unknown = agentRefIssues.filter((i) => !i.inCatalog);
     if (installable.length > 0) {
       const names = [...new Set(installable.map((i) => i.agentName))];
       flag(
-        `- AGENT REFS: ${installable.length} reference(s) point at an agent the catalog can install but this project has not (${names.join(", ")}) (${installable.slice(0, 3).map(describeAgent).join("; ")}${installable.length > 3 ? "; \u2026" : ""})`,
-        `${installable.length} rule/agent reference(s) send agents after ${names.join(", ")}, which is available but not installed`,
+        `- AGENT REFS: ${installable.length} reference(s) point at ${referent(installable)} the catalog can install but this project has not (${names.join(", ")}) (${installable.slice(0, 3).map(describeAgent).join("; ")}${installable.length > 3 ? "; \u2026" : ""})`,
+        `${installable.length} rule/agent reference(s) ${routedTo(installable, names)}, which is available but not installed`,
         "find its catalog id and run `haus recommend --include <id>` then `haus apply --write`"
       );
     }
+    if (gatedOut.length > 0) {
+      const names = [...new Set(gatedOut.map((i) => i.agentName))];
+      const unmet = names.map((name) => {
+        const signal = gatedOutAgentSignals.get(name);
+        return signal ? `${name} needs ${signal}` : name;
+      }).join("; ");
+      suggest(
+        `- AGENT REFS: ${gatedOut.length} reference(s) name ${referent(gatedOut)} the catalog gates out of this project's stack (${unmet}) (${gatedOut.slice(0, 3).map(describeAgent).join("; ")}${gatedOut.length > 3 ? "; \u2026" : ""})`,
+        `${gatedOut.length} rule/agent reference(s) ${routedTo(gatedOut, names)}, which the catalog does not offer a project with this stack (${unmet}) \u2014 the reference is upstream prose, not a missing install`,
+        `nothing to install here: correct or drop the reference upstream (catalog-owned prose) \u2014 the catalog gates ${names.join(", ")} out of this stack on purpose`
+      );
+    }
     if (unknown.length > 0) {
       const names = [...new Set(unknown.map((i) => i.agentName))];
       suggest(
-        `- AGENT REFS: ${unknown.length} reference(s) name an agent that exists neither here nor in the catalog (${names.join(", ")}) (${unknown.slice(0, 3).map(describeAgent).join("; ")}${unknown.length > 3 ? "; \u2026" : ""})`,
-        `${unknown.length} rule/agent reference(s) send agents after ${names.join(", ")}, which was never shipped`,
+        `- AGENT REFS: ${unknown.length} reference(s) name ${referent(unknown)} that exists neither here nor in the catalog (${names.join(", ")}) (${unknown.slice(0, 3).map(describeAgent).join("; ")}${unknown.length > 3 ? "; \u2026" : ""})`,
+        `${unknown.length} rule/agent reference(s) ${routedTo(unknown, names)}, which was never shipped`,
         "correct or drop the reference upstream (catalog-owned prose), so agents stop being sent after a tool that does not exist"
       );
     }
@@ -9193,9 +9404,6 @@ async function runDoctor(options) {
   if (skillRefIssues.length === 0 && agentRefIssues.length === 0) {
     ok("- SKILL REFS: OK (no unresolved cross-skill or agent references)");
   }
-  const recommendedIds = new Set(
-    (recommendation?.recommended ?? []).map((entry) => entry.id).filter((id) => typeof id === "string")
-  );
   if (catalogItems !== null && recommendedIds.size > 0) {
     const catalogIds = new Set(catalogItems.map((item) => item.id));
     const excludedIds = new Set(await readProjectExcludedIds(root));
@@ -9415,7 +9623,7 @@ async function runDoctor(options) {
 }
 
 // src/commands/update.ts
-import path51 from "node:path";
+import path52 from "node:path";
 init_github_rate_limit();
 init_private_catalog_access();
 
@@ -9442,8 +9650,8 @@ async function refreshProjectApply(root) {
 
 // src/install/apply.ts
 import crypto3 from "node:crypto";
-import path49 from "node:path";
-import fs42 from "fs-extra";
+import path50 from "node:path";
+import fs43 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -9550,72 +9758,146 @@ ${rest}`;
 ${content2}`;
 }
 
+// src/install/internal-channel.ts
+init_fs();
+import path49 from "node:path";
+import fs42 from "fs-extra";
+var INSTALL_CONFIG_SCHEMA = "haus-install-config/1";
+var INTERNAL_NAME_PREFIXES = ["request", "slack-cowork"];
+function internalPrefixMatch(name) {
+  return INTERNAL_NAME_PREFIXES.some(
+    (prefix) => name === prefix || name.startsWith(`${prefix}-`) || name.startsWith(`${prefix}.`)
+  );
+}
+function isInternalAsset(stableId) {
+  const separator = stableId.indexOf(".");
+  if (separator === -1) return false;
+  const kind = stableId.slice(0, separator);
+  const name = stableId.slice(separator + 1);
+  if (kind !== "skill" && kind !== "agent") return false;
+  return internalPrefixMatch(name);
+}
+function installConfigPath() {
+  return path49.join(globalClaudeDir(), "haus", "install-config.json");
+}
+async function readInstallConfig() {
+  const raw = await readJson(installConfigPath());
+  if (!raw || typeof raw.internal !== "boolean") return void 0;
+  return raw;
+}
+async function writeInstallConfig(config) {
+  await writeJson(installConfigPath(), {
+    _schema: INSTALL_CONFIG_SCHEMA,
+    internal: config.internal,
+    source: config.source,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function removeInstallConfig() {
+  const p = installConfigPath();
+  if (fs42.pathExistsSync(p)) await fs42.remove(p);
+}
+function envOverride() {
+  const raw = process.env.HAUS_INTERNAL_CHANNEL?.trim().toLowerCase();
+  if (raw === void 0 || raw === "") return void 0;
+  if (["1", "true", "yes", "on"].includes(raw)) return true;
+  if (["0", "false", "no", "off"].includes(raw)) return false;
+  return void 0;
+}
+function manifestHasInternal(manifest) {
+  return (manifest?.files ?? []).some((file) => isInternalAsset(file.stableId));
+}
+async function resolveInternalChannel(manifest, requested) {
+  if (requested !== void 0) return { enabled: requested, source: "flag" };
+  const override = envOverride();
+  if (override !== void 0) return { enabled: override, source: "env" };
+  const config = await readInstallConfig();
+  if (config) return { enabled: config.internal, source: "config" };
+  if (manifestHasInternal(manifest)) return { enabled: true, source: "grandfathered" };
+  return { enabled: false, source: "default" };
+}
+
 // src/install/apply.ts
 var SCHEMA_VERSION2 = "1";
+async function pruneEmptyDirsUpward(dirs, stopAt) {
+  const ordered = [...new Set(dirs)].sort((a, b) => b.length - a.length);
+  for (const start of ordered) {
+    let dir = start;
+    while (dir.startsWith(stopAt) && dir !== stopAt) {
+      try {
+        if ((await fs43.readdir(dir)).length > 0) break;
+        await fs43.remove(dir);
+      } catch {
+        break;
+      }
+      dir = path50.dirname(dir);
+    }
+  }
+}
 function hashContent(content2) {
   return `sha256-${crypto3.createHash("sha256").update(normaliseLF(content2)).digest("hex")}`;
 }
 function destFileMissing(destPath) {
   try {
-    return !fs42.statSync(destPath).isFile();
+    return !fs43.statSync(destPath).isFile();
   } catch {
     return true;
   }
 }
 function sourceVersion() {
   try {
-    const pkgPath = path49.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs42.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path50.join(packageRoot(), "package.json");
+    const pkg = JSON.parse(fs43.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
   }
 }
 function globalSrcDir() {
-  return path49.join(packageRoot(), "library", "global");
+  return path50.join(packageRoot(), "library", "global");
 }
 function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
-  const skillDir = path49.join(skillsDir, skillName);
+  const skillDir = path50.join(skillsDir, skillName);
   const entries = [];
-  for (const rel of fs42.readdirSync(skillDir, { recursive: true })) {
+  for (const rel of fs43.readdirSync(skillDir, { recursive: true })) {
     if (rel === "SKILL.md") continue;
-    const abs = path49.join(skillDir, rel);
-    if (!fs42.statSync(abs).isFile()) continue;
-    const posixRel = rel.split(path49.sep).join("/");
+    const abs = path50.join(skillDir, rel);
+    if (!fs43.statSync(abs).isFile()) continue;
+    const posixRel = rel.split(path50.sep).join("/");
     entries.push({
       stableId: `skill.${skillName}.${posixRel.replace(/\//g, ".")}`,
-      srcRelPath: path49.join("library", "global", "skills", skillName, rel),
-      destPath: path49.join(claudeDir, "skills", skillName, rel)
+      srcRelPath: path50.join("library", "global", "skills", skillName, rel),
+      destPath: path50.join(claudeDir, "skills", skillName, rel)
     });
   }
   return entries;
 }
 function collectFlatChannel(srcDir, claudeDir, dirName, idPrefix) {
   const entries = [];
-  const channelDir = path49.join(srcDir, dirName);
-  if (!fs42.pathExistsSync(channelDir)) return entries;
-  for (const fileName of fs42.readdirSync(channelDir)) {
+  const channelDir = path50.join(srcDir, dirName);
+  if (!fs43.pathExistsSync(channelDir)) return entries;
+  for (const fileName of fs43.readdirSync(channelDir)) {
     if (!fileName.endsWith(".md")) continue;
     const name = fileName.slice(0, -".md".length);
     entries.push({
       stableId: `${idPrefix}.${name}`,
-      srcRelPath: path49.join("library", "global", dirName, fileName),
-      destPath: path49.join(claudeDir, dirName, fileName)
+      srcRelPath: path50.join("library", "global", dirName, fileName),
+      destPath: path50.join(claudeDir, dirName, fileName)
     });
   }
   return entries;
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  const skillsDir = path49.join(srcDir, "skills");
-  if (fs42.pathExistsSync(skillsDir)) {
-    for (const skillName of fs42.readdirSync(skillsDir)) {
-      const skillFile = path49.join(skillsDir, skillName, "SKILL.md");
-      if (fs42.pathExistsSync(skillFile)) {
+  const skillsDir = path50.join(srcDir, "skills");
+  if (fs43.pathExistsSync(skillsDir)) {
+    for (const skillName of fs43.readdirSync(skillsDir)) {
+      const skillFile = path50.join(skillsDir, skillName, "SKILL.md");
+      if (fs43.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path49.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path49.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path50.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path50.join(claudeDir, "skills", skillName, "SKILL.md")
         });
         entries.push(...collectSkillAuxFiles(skillsDir, claudeDir, skillName));
       }
@@ -9626,7 +9908,7 @@ function collectSourceFiles(srcDir, claudeDir) {
   return entries;
 }
 async function applyInstall(options = {}) {
-  const { dryRun = false, force = false, check = false } = options;
+  const { dryRun = false, force = false, check = false, internal } = options;
   const claudeDir = globalClaudeDir();
   const srcDir = globalSrcDir();
   const source = sourceVersion();
@@ -9637,7 +9919,10 @@ async function applyInstall(options = {}) {
   ]);
   const existingManifest = await readManifest();
   const manifestByDest = new Map(existingManifest?.files.map((f) => [f.destPath, f]) ?? []);
-  const sourceFiles = collectSourceFiles(srcDir, claudeDir);
+  const internalChannel = await resolveInternalChannel(existingManifest, internal);
+  const sourceFiles = collectSourceFiles(srcDir, claudeDir).filter(
+    (entry) => internalChannel.enabled || !isInternalAsset(entry.stableId)
+  );
   const result = {
     created: [],
     updated: [],
@@ -9647,11 +9932,12 @@ async function applyInstall(options = {}) {
     deleted: [],
     hookIds: [],
     configDirMigration,
+    internalChannel,
     drift: false
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path49.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path50.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -9680,7 +9966,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs42.pathExistsSync(entry.destPath);
+    const destExists = fs43.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -9720,7 +10006,7 @@ async function applyInstall(options = {}) {
   }
   let mergedSettings;
   if (!check) {
-    const fragmentPath = path49.join(srcDir, "settings-fragments", "hooks.json");
+    const fragmentPath = path50.join(srcDir, "settings-fragments", "hooks.json");
     const fragments = await loadHooksFragment(fragmentPath);
     const settings = await readSettings();
     const { settings: hookSettings, addedIds } = mergeHooks(settings, fragments);
@@ -9731,6 +10017,7 @@ async function applyInstall(options = {}) {
     result.hookIds = addedIds;
   }
   if (!check && existingManifest) {
+    const emptiedDirs = /* @__PURE__ */ new Set();
     const currentDestPaths = new Set(sourceFiles.map((f) => f.destPath));
     for (const entry of existingManifest.files) {
       if (currentDestPaths.has(entry.destPath)) continue;
@@ -9739,19 +10026,21 @@ async function applyInstall(options = {}) {
         manifestFiles.push(entry);
         continue;
       }
-      if (!fs42.pathExistsSync(entry.destPath)) continue;
+      if (!fs43.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 fs42.remove(entry.destPath);
+        if (!dryRun) await fs43.remove(entry.destPath);
+        emptiedDirs.add(path50.dirname(entry.destPath));
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
         result.skipped.push(entry.destPath);
       }
     }
+    if (!dryRun) await pruneEmptyDirsUpward(emptiedDirs, claudeDir);
   }
   if (!dryRun && !check && mergedSettings) {
     await writeSettings(mergedSettings);
@@ -9762,9 +10051,27 @@ async function applyInstall(options = {}) {
       existingManifest?.plugins
     );
     await writeManifest(manifest);
+    if (internalChannel.source === "grandfathered")
+      await writeInstallConfig({ internal: true, source: "grandfathered" });
+    if (internalChannel.source === "flag")
+      await writeInstallConfig({ internal: internalChannel.enabled, source: "explicit" });
   }
   return result;
 }
+function printInternalChannel(result, prefix) {
+  const { source, enabled } = result.internalChannel;
+  if (source === "grandfathered") {
+    log(
+      `${prefix}Internal channel kept on: this machine already had the request skills. Turn it off with \`haus install --no-internal\`.`
+    );
+    return;
+  }
+  if (!enabled && result.deleted.some((p) => p.includes("request") || p.includes("slack-cowork"))) {
+    log(
+      `${prefix}Internal channel is off \u2014 the request skills and slack-cowork were removed. Bring them back with \`haus install --internal\`.`
+    );
+  }
+}
 function printApplyResult(result, dryRun) {
   const prefix = dryRun ? "[dry-run] " : "";
   printConfigDirMigration(result.configDirMigration);
@@ -9788,6 +10095,7 @@ function printApplyResult(result, dryRun) {
   if (result.hookIds.length) {
     log(`${prefix}Hooks added: ${result.hookIds.join(", ")}`);
   }
+  printInternalChannel(result, prefix);
   if (result.drift) {
     warn("Install drift detected \u2014 run `haus install` to sync.");
   }
@@ -9819,7 +10127,7 @@ function summarizeLockDiff(before, after) {
 // src/update/lockfile.ts
 import { constants as fsConstants } from "node:fs";
 import { copyFile, mkdir, readFile as readFile2 } from "node:fs/promises";
-import path50 from "node:path";
+import path51 from "node:path";
 init_fs();
 init_paths();
 async function readLockSummary(root) {
@@ -9859,7 +10167,7 @@ async function backupLockfile(root) {
     await mkdir(backupDir, { recursive: true });
     let stamp = Date.now();
     for (; ; ) {
-      const dest = path50.join(backupDir, lockBackupFileName(stamp));
+      const dest = path51.join(backupDir, lockBackupFileName(stamp));
       try {
         await copyFile(lockPath, dest, fsConstants.COPYFILE_EXCL);
         return;
@@ -9910,7 +10218,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile2(path50.join(root, ".claude", "settings.json"), "utf8");
+    await readFile2(path51.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -9955,7 +10263,7 @@ async function runUpdate(options) {
     return;
   }
   if (options.check) {
-    const pkgJson2 = await readJson(path51.join(packageRoot(), "package.json"));
+    const pkgJson2 = await readJson(path52.join(packageRoot(), "package.json"));
     const currentVersion2 = pkgJson2?.version ?? "0.0.0";
     const [
       status,
@@ -10007,7 +10315,7 @@ async function runUpdate(options) {
     }
     return;
   }
-  const pkgJson = await readJson(path51.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path52.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -10078,7 +10386,7 @@ async function runFromHookCheck(root) {
   try {
     const summary = await readLockSummary(root);
     if (summary.count === 0) return;
-    const pkgJson = await readJson(path51.join(packageRoot(), "package.json"));
+    const pkgJson = await readJson(path52.join(packageRoot(), "package.json"));
     const currentVersion = pkgJson?.version ?? "0.0.0";
     const pin = readProjectCatalogPin(root);
     const honoursPin = pin.kind === "pinned" && summary.catalogRef === pin.ref;
@@ -10145,6 +10453,7 @@ async function refreshGlobalInstall() {
 async function ensureCatalogPinnedPlugins(root) {
   try {
     const pins = await loadCatalogPluginPins(root);
+    await cleanupStaleGlobalPlugins(pins);
     const ensured = await ensureGlobalPlugins(pins);
     await recordManifestPlugins(
       pins.filter((pin) => ensured.ensured.includes(pin.id)).map((pin) => ({ ...pin, installedAt: (/* @__PURE__ */ new Date()).toISOString() }))
@@ -10153,11 +10462,21 @@ async function ensureCatalogPinnedPlugins(root) {
     warn(`Could not update global plugins: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function detectGlobalPluginDrift(root) {
+async function detectGlobalPluginDrift(root, deps = {}) {
   try {
     const pins = await loadCatalogPluginPins(root);
-    const state = await probePluginEnv();
-    return pluginDriftStatus(planPluginActions(pins, state), { matchRef: true });
+    const state = await probePluginEnv(deps);
+    const manifest = await readManifest();
+    const recorded = (manifest?.plugins ?? []).filter(isValidPin);
+    const protectedPins = [...pins, ...DEFAULT_GLOBAL_PLUGINS];
+    const stale = planStalePluginRemovals(
+      protectedPins,
+      [...recorded, ...FORMER_GLOBAL_PLUGINS],
+      state
+    );
+    const pinned = pluginDriftStatus(planPluginActions(pins, state), { matchRef: true });
+    if (pinned === null) return null;
+    return pinned || stale.length > 0;
   } catch {
     return null;
   }
@@ -10262,7 +10581,7 @@ init_exec();
 init_logger();
 import { existsSync as existsSync2 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import path52 from "node:path";
+import path53 from "node:path";
 var GIT_LOCATION_VARS = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -10322,11 +10641,11 @@ async function runClone(url, opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const target = path52.resolve(opts.dir?.trim() || repoNameFromUrl(url));
+  const target = path53.resolve(opts.dir?.trim() || repoNameFromUrl(url));
   if (existsSync2(target) && !await isEmptyDirectory(target)) {
     const check = await checkExistingTarget(target, url);
     if (check.kind === "matches") {
-      log(`\u2022 ${path52.basename(target)} already cloned here, matches ${url} \u2014 skipped`);
+      log(`\u2022 ${path53.basename(target)} already cloned here, matches ${url} \u2014 skipped`);
       return;
     }
     const message2 = check.kind === "not-a-repo" ? `${target} already exists and is not a git repository \u2014 refusing to clone ${url} there. Remove or rename it, or pass a different [dir].` : `${target} already exists as a different repository (origin: ${check.origin ?? "(no origin remote)"}) \u2014 refusing to clone ${url} there. Remove or rename it, or pass a different [dir].`;
@@ -10375,8 +10694,8 @@ function isCatalogItemInstallable(item) {
 
 // src/install/scaffold.ts
 init_logger();
-import path53 from "node:path";
-import fs43 from "fs-extra";
+import path54 from "node:path";
+import fs44 from "fs-extra";
 async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   const scaffolded = [];
   const skipped = [];
@@ -10389,27 +10708,27 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
     skipped.push(name);
     if (outcome === "skipped-exists") skippedExisting.push(name);
   };
-  const realRoot = await fs43.realpath(catalogRoot).catch(() => null);
+  const realRoot = await fs44.realpath(catalogRoot).catch(() => null);
   for (const item of items) {
     if (item.type !== "config") continue;
-    const sourcePath = path53.resolve(catalogRoot, item.path);
-    const rel = path53.relative(catalogRoot, sourcePath);
-    const escapes = rel === "" || path53.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
+    const sourcePath = path54.resolve(catalogRoot, item.path);
+    const rel = path54.relative(catalogRoot, sourcePath);
+    const escapes = rel === "" || path54.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
     if (escapes) {
       warn(`Skipping ${item.id}: path '${item.path}' escapes the catalog root`);
       continue;
     }
-    const realSource = await fs43.realpath(sourcePath).catch(() => null);
+    const realSource = await fs44.realpath(sourcePath).catch(() => null);
     if (!realRoot || !realSource) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
     }
-    const realRel = path53.relative(realRoot, realSource);
-    if (realRel !== "" && (path53.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
+    const realRel = path54.relative(realRoot, realSource);
+    if (realRel !== "" && (path54.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
       warn(`Skipping ${item.id}: path '${item.path}' resolves outside the catalog root`);
       continue;
     }
-    const stat = await fs43.lstat(sourcePath).catch(() => null);
+    const stat = await fs44.lstat(sourcePath).catch(() => null);
     if (!stat) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -10419,14 +10738,14 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       continue;
     }
     if (stat.isFile()) {
-      const filename = path53.basename(sourcePath);
-      const dest = path53.join(projectRoot, filename);
+      const filename = path54.basename(sourcePath);
+      const dest = path54.join(projectRoot, filename);
       record(filename, await scaffoldFile(sourcePath, dest, item.id, projectRoot, opts));
     } else if (stat.isDirectory()) {
-      const entries = await fs43.readdir(sourcePath);
+      const entries = await fs44.readdir(sourcePath);
       for (const entry of entries) {
-        const src = path53.join(sourcePath, entry);
-        const dest = path53.join(projectRoot, entry);
+        const src = path54.join(sourcePath, entry);
+        const dest = path54.join(projectRoot, entry);
         record(entry, await scaffoldFile(src, dest, item.id, projectRoot, opts));
       }
     }
@@ -10434,42 +10753,42 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   return { scaffolded, skipped, skippedExisting };
 }
 async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
-  const destDisplay = path53.relative(projectRoot, dest) || path53.basename(dest);
-  const srcStat = await fs43.lstat(src).catch(() => null);
+  const destDisplay = path54.relative(projectRoot, dest) || path54.basename(dest);
+  const srcStat = await fs44.lstat(src).catch(() => null);
   if (!srcStat) {
-    warn(`Skipping ${path53.basename(src)}: source not found`);
+    warn(`Skipping ${path54.basename(src)}: source not found`);
     return "skipped-refused";
   }
   if (srcStat.isSymbolicLink()) {
-    warn(`Skipping ${path53.basename(src)}: source is a symlink`);
+    warn(`Skipping ${path54.basename(src)}: source is a symlink`);
     return "skipped-refused";
   }
-  const exists = await fs43.pathExists(dest);
+  const exists = await fs44.pathExists(dest);
   if (exists && !opts.force) {
     warn(`Skipping ${destDisplay}: already exists \u2014 re-run with --force to overwrite it`);
     return "skipped-exists";
   }
   if (opts.dryRun) {
-    log(`[dry-run] would ${exists ? "overwrite" : "create"} ${path53.basename(dest)} (${itemId})`);
+    log(`[dry-run] would ${exists ? "overwrite" : "create"} ${path54.basename(dest)} (${itemId})`);
     return "scaffolded";
   }
   if (exists && opts.force) {
-    await fs43.remove(dest);
+    await fs44.remove(dest);
   }
-  await fs43.ensureDir(path53.dirname(dest));
-  await fs43.copy(src, dest, {
+  await fs44.ensureDir(path54.dirname(dest));
+  await fs44.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 !fs43.lstatSync(s).isSymbolicLink();
+        return !fs44.lstatSync(s).isSymbolicLink();
       } catch {
         return false;
       }
     }
   });
-  if (!opts.quiet) log(`${exists ? "Overwrote" : "Created"} ${path53.basename(dest)} (${itemId})`);
+  if (!opts.quiet) log(`${exists ? "Overwrote" : "Created"} ${path54.basename(dest)} (${itemId})`);
   return "scaffolded";
 }
 
@@ -10601,7 +10920,7 @@ async function runDecisionsGuard(options = {}) {
 }
 
 // src/commands/decisions.ts
-import path54 from "node:path";
+import path55 from "node:path";
 
 // src/decisions/next-number.ts
 async function nextDecisionNumber(root) {
@@ -10712,7 +11031,7 @@ async function runDecisions(sub, arg, options = {}) {
     return;
   }
   if (sub === "validate") {
-    const target = arg ? path54.resolve(root, arg) : void 0;
+    const target = arg ? path55.resolve(root, arg) : void 0;
     if (!target) {
       error("usage: haus decisions validate <path-to-decision.md>");
       process.exitCode = 1;
@@ -11181,27 +11500,27 @@ function guardBash(command) {
 }
 
 // src/security/guard-file-access.ts
-import fs44 from "node:fs";
-import path55 from "node:path";
+import fs45 from "node:fs";
+import path56 from "node:path";
 function matchesDenyTier(candidate) {
   const normalized = normalizePathForMatch(candidate);
   return DENY_PATH_REGEXES.some((re) => re.test(normalized));
 }
 function resolveOnDisk(candidate) {
   try {
-    const resolved = fs44.realpathSync(candidate);
-    return resolved === path55.resolve(candidate) ? {} : { resolved };
+    const resolved = fs45.realpathSync(candidate);
+    return resolved === path56.resolve(candidate) ? {} : { resolved };
   } catch {
     try {
-      if (fs44.lstatSync(candidate).isSymbolicLink()) return { unverifiable: true };
+      if (fs45.lstatSync(candidate).isSymbolicLink()) return { unverifiable: true };
     } catch {
     }
-    const parent = path55.dirname(candidate);
+    const parent = path56.dirname(candidate);
     if (parent === candidate) return {};
     const viaParent = resolveOnDisk(parent);
     if (viaParent.unverifiable) return { unverifiable: true };
     if (viaParent.resolved)
-      return { resolved: path55.join(viaParent.resolved, path55.basename(candidate)) };
+      return { resolved: path56.join(viaParent.resolved, path56.basename(candidate)) };
     return {};
   }
 }
@@ -11751,9 +12070,9 @@ function buildOptInEligible(items, skipped) {
 }
 
 // src/commands/workspace/discover.ts
-import path56 from "node:path";
+import path57 from "node:path";
 import fg6 from "fast-glob";
-import YAML3 from "yaml";
+import YAML4 from "yaml";
 init_fs();
 init_logger();
 var DEFAULT_MAX_DEPTH = 3;
@@ -11794,10 +12113,10 @@ async function findRepoRoots(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const gitDirs = /* @__PURE__ */ new Set();
   const manifestDirs = /* @__PURE__ */ new Set();
   for (const match of gitMatches) {
-    gitDirs.add(path56.posix.dirname(match));
+    gitDirs.add(path57.posix.dirname(match));
   }
   for (const match of manifestMatches) {
-    manifestDirs.add(path56.posix.dirname(match));
+    manifestDirs.add(path57.posix.dirname(match));
   }
   const repoRoots = [...gitDirs];
   const manifestSorted = [...manifestDirs].sort(
@@ -11814,9 +12133,9 @@ async function findRepoRoots(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
 async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const repoRoots = (await findRepoRoots(workspaceRoot, maxDepth)).filter((dir) => dir !== ".");
   return mapWithConcurrency(repoRoots, async (relDir) => {
-    const absDir = path56.resolve(workspaceRoot, relDir);
-    const pkg = await readJson(path56.join(absDir, "package.json"));
-    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path56.basename(absDir);
+    const absDir = path57.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path57.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path57.basename(absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir);
@@ -11852,14 +12171,14 @@ function mergeWorkspaceConfig(existing, discovered, opts = {}) {
   };
 }
 function renderWorkspaceYaml(config) {
-  return YAML3.stringify({
+  return YAML4.stringify({
     client: config.client,
     repos: config.repos.map((r) => ({ name: r.name, path: r.path, role: r.role ?? "auto" })),
     relationships: config.relationships
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path56.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path57.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -12221,23 +12540,39 @@ function toManifestPlugin(pin) {
 async function runInstall(options, deps = {}) {
   const ensure = deps.ensureGlobalPlugins ?? ensureGlobalPlugins;
   const probe = deps.probePluginEnv ?? probePluginEnv;
+  const cleanup = deps.cleanupStaleGlobalPlugins ?? cleanupStaleGlobalPlugins;
   try {
     const result = await applyInstall({
       dryRun: options.dryRun,
       force: options.force,
-      check: options.check
+      check: options.check,
+      internal: options.internal
     });
     if (!options.postinstall) printApplyResult(result, options.dryRun ?? false);
     const pins = [...DEFAULT_GLOBAL_PLUGINS];
     if (options.check) {
       const state = await probe();
       const pluginDrift = pluginDriftStatus(planPluginActions(pins, state), { matchRef: false });
+      const manifest = await readManifest();
+      const recorded = (manifest?.plugins ?? []).filter(isValidPin);
+      const protectedPins = [...pins, ...DEFAULT_GLOBAL_PLUGINS];
+      const stale = planStalePluginRemovals(
+        protectedPins,
+        [...recorded, ...FORMER_GLOBAL_PLUGINS],
+        state
+      );
       if (pluginDrift === true) {
         log("Global plugin drift: a haus-managed plugin is missing or disabled.");
       }
-      if (result.drift || pluginDrift === true) process.exitCode = 1;
+      if (stale.length > 0) {
+        log(
+          `Global plugin drift: formerly managed plugin(s) still installed: ${stale.map((p) => `${p.plugin}@${p.marketplace}`).join(", ")}.`
+        );
+      }
+      if (result.drift || pluginDrift === true || stale.length > 0) process.exitCode = 1;
       return;
     }
+    await cleanup(pins, { dryRun: options.dryRun });
     const ensured = await ensure(pins, { dryRun: options.dryRun });
     if (!options.dryRun) {
       await recordManifestPlugins(
@@ -12276,11 +12611,11 @@ async function runInstall(options, deps = {}) {
 }
 
 // src/commands/new.ts
-import path58 from "node:path";
+import path59 from "node:path";
 
 // src/new-project/create-project.ts
-import path57 from "node:path";
-import fs45 from "fs-extra";
+import path58 from "node:path";
+import fs46 from "fs-extra";
 init_exec();
 init_logger();
 
@@ -12465,10 +12800,10 @@ var defaultDeps = {
 };
 var NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
 async function recordPackageManager(projectPath, pm, deps) {
-  const pkgPath = path57.join(projectPath, "package.json");
+  const pkgPath = path58.join(projectPath, "package.json");
   let pkg;
   try {
-    pkg = await fs45.readJson(pkgPath);
+    pkg = await fs46.readJson(pkgPath);
   } catch {
     return {};
   }
@@ -12483,7 +12818,7 @@ async function recordPackageManager(projectPath, pm, deps) {
       note: `installed ${pm} is ${version}, which haus does not support \u2014 the package manager was not recorded, so the scanner will report it as unknown until you upgrade`
     };
   }
-  await fs45.writeJson(pkgPath, { ...pkg, packageManager: field }, { spaces: 2 });
+  await fs46.writeJson(pkgPath, { ...pkg, packageManager: field }, { spaces: 2 });
   return {};
 }
 var CONFIG_TOOLING = {
@@ -12496,12 +12831,12 @@ var CONFIG_TOOLING = {
   }
 };
 async function ensureConfigTooling(projectPath, scaffolded) {
-  const needed = scaffolded.map((file) => CONFIG_TOOLING[path57.basename(file)]).filter((entry) => entry !== void 0);
+  const needed = scaffolded.map((file) => CONFIG_TOOLING[path58.basename(file)]).filter((entry) => entry !== void 0);
   if (needed.length === 0) return [];
-  const pkgPath = path57.join(projectPath, "package.json");
+  const pkgPath = path58.join(projectPath, "package.json");
   let pkg;
   try {
-    pkg = await fs45.readJson(pkgPath);
+    pkg = await fs46.readJson(pkgPath);
   } catch {
     return [];
   }
@@ -12525,12 +12860,12 @@ async function ensureConfigTooling(projectPath, scaffolded) {
     }
   }
   if (!changed) return [];
-  await fs45.writeJson(pkgPath, { ...pkg, devDependencies, scripts }, { spaces: 2 });
+  await fs46.writeJson(pkgPath, { ...pkg, devDependencies, scripts }, { spaces: 2 });
   return added;
 }
 async function createProject(opts, deps = defaultDeps) {
   const steps = [];
-  const projectPath = path57.resolve(opts.parentDir, opts.name);
+  const projectPath = path58.resolve(opts.parentDir, opts.name);
   const installHint = `cd ${opts.name} && ${opts.pm}${opts.pm === "yarn" ? "" : " install"}`;
   const fail = (step, detail) => {
     steps.push({ step, status: "failed", detail });
@@ -12538,20 +12873,20 @@ async function createProject(opts, deps = defaultDeps) {
   };
   const stack = getStack(opts.stackId);
   if (!stack) return fail("preflight", `Unknown stack "${opts.stackId}". Run \`haus new --list\`.`);
-  const parentStat = await fs45.stat(path57.dirname(projectPath)).catch(() => null);
+  const parentStat = await fs46.stat(path58.dirname(projectPath)).catch(() => null);
   if (!parentStat?.isDirectory()) {
     return fail(
       "preflight",
       `Parent directory ${opts.parentDir} is not an existing directory \u2014 pass an existing one to --dir.`
     );
   }
-  if (!NAME_RE.test(opts.name) || opts.name.includes("/") || opts.name.includes("\\") || path57.dirname(projectPath) !== path57.resolve(opts.parentDir)) {
+  if (!NAME_RE.test(opts.name) || opts.name.includes("/") || opts.name.includes("\\") || path58.dirname(projectPath) !== path58.resolve(opts.parentDir)) {
     return fail(
       "preflight",
       `Invalid project name "${opts.name}" (lowercase letters, digits, . _ - only).`
     );
   }
-  if (await fs45.pathExists(projectPath)) {
+  if (await fs46.pathExists(projectPath)) {
     return fail("preflight", `Target ${projectPath} already exists \u2014 refusing to write into it.`);
   }
   const scaffoldArgs = stack.scaffold.args.map(
@@ -12623,13 +12958,13 @@ async function createProject(opts, deps = defaultDeps) {
     });
     if (scaffold.exitCode !== 0) {
       const why = scaffold.killed ? `${pinned} did not complete: ${scaffold.stderr.trim() || `timed out after ${SCAFFOLD_TIMEOUT_MS}ms`}. Scaffolders that stall this way are usually waiting on a prompt despite --yes \u2014 run it yourself to see: npx ${npxArgs.join(" ")}` : `${pinned} exited ${scaffold.exitCode}.`;
-      const leftBehind = await fs45.pathExists(projectPath) ? ` The directory was left for inspection \u2014 review it and remove it manually if unwanted (haus never auto-deletes).` : "";
+      const leftBehind = await fs46.pathExists(projectPath) ? ` The directory was left for inspection \u2014 review it and remove it manually if unwanted (haus never auto-deletes).` : "";
       return fail("scaffold", `${why}${leftBehind}`);
     }
     steps.push({ step: "scaffold", status: "done" });
     phase = "git";
     if (!opts.json) log("\u25B6 git: init/branch/commit");
-    if (!await fs45.pathExists(path57.join(projectPath, ".git"))) {
+    if (!await fs46.pathExists(path58.join(projectPath, ".git"))) {
       const init = await deps.git(["init"], { cwd: projectPath });
       if (init.exitCode !== 0) return fail("git", `git init failed: ${init.stderr}`);
     }
@@ -12855,7 +13190,7 @@ function resolveNewOptions(stackArg, nameArg, flags, cwd) {
   if (flags.dir !== void 0 && flags.dir.trim() === "") {
     return { ok: false, error: "--dir needs a path (omit it to scaffold into the cwd)." };
   }
-  const parentDir = flags.dir === void 0 ? cwd : path58.resolve(cwd, flags.dir);
+  const parentDir = flags.dir === void 0 ? cwd : path59.resolve(cwd, flags.dir);
   const pm = flags.pm ?? "yarn";
   if (!PMS.includes(pm)) {
     return { ok: false, error: `Unsupported --pm "${pm}" \u2014 use yarn, npm, or pnpm.` };
@@ -12953,7 +13288,7 @@ async function runRecommend(options) {
 }
 
 // src/commands/remove.ts
-import path59 from "node:path";
+import path60 from "node:path";
 init_fs();
 init_logger();
 init_paths();
@@ -13060,7 +13395,7 @@ async function runRemove(ids, options = {}) {
   }
   const allAbs = cleared.flatMap(({ existing }) => existing.map(({ abs }) => abs));
   const backupRoot = await backupTrackedPaths(root, allAbs, say, "remove");
-  report.backupDir = backupRoot === null ? null : path59.basename(backupRoot);
+  report.backupDir = backupRoot === null ? null : path60.basename(backupRoot);
   for (const { id, existing } of cleared) {
     await deleteTrackedPaths(root, id, existing, { verb: "Removed", reason: "" }, say);
   }
@@ -13101,7 +13436,9 @@ async function runRescan(options = {}) {
   const context = await scanProject(root, { persist: !dryRun });
   if (!dryRun) {
     try {
-      await ensureGlobalPlugins(await loadCatalogPluginPins(root));
+      const pins = await loadCatalogPluginPins(root);
+      await cleanupStaleGlobalPlugins(pins);
+      await ensureGlobalPlugins(pins);
     } catch (err) {
       warn(`Could not refresh global plugins: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -13148,8 +13485,8 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path60 from "node:path";
-import fs46 from "fs-extra";
+import path61 from "node:path";
+import fs47 from "fs-extra";
 
 // src/claude/managed-paths.ts
 init_paths();
@@ -13168,7 +13505,7 @@ init_paths();
 async function collectCoreManagedPaths(root) {
   const existing = [];
   for (const abs of coreManagedAbsolutePaths(root)) {
-    if (await fs46.pathExists(abs)) existing.push(abs);
+    if (await fs47.pathExists(abs)) existing.push(abs);
   }
   return existing;
 }
@@ -13182,7 +13519,7 @@ async function collectLockTrackedPaths(root) {
     const unsafeByRel = await unsafeReasonsFor(root, relPaths);
     const existing = await resolveExistingTrackedPaths(root, id, relPaths, log, unsafeByRel);
     for (const [rel, reason] of unsafeByRel) {
-      if (reason !== null) preserved.push(path60.resolve(root, rel));
+      if (reason !== null) preserved.push(path61.resolve(root, rel));
     }
     if (existing.length === 0) continue;
     const gate = await hashGateEntry(root, { hash: row.hash }, existing);
@@ -13198,51 +13535,51 @@ async function collectLockTrackedPaths(root) {
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs46.pathExists(settingsPath)) return false;
+  if (!await fs47.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path60.join(root, "CLAUDE.md");
-  if (!await fs46.pathExists(filePath)) return false;
-  const text = await fs46.readFile(filePath, "utf8");
+  const filePath = path61.join(root, "CLAUDE.md");
+  if (!await fs47.pathExists(filePath)) return false;
+  const text = await fs47.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs46.pathExists(settingsPath)) return false;
+  if (!await fs47.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 ${path60.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path61.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs46.remove(settingsPath);
-  log(`Removed ${path60.relative(root, settingsPath)} (no user-owned settings remained).`);
+  await fs47.remove(settingsPath);
+  log(`Removed ${path61.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path60.join(root, "CLAUDE.md");
-  if (!await fs46.pathExists(filePath)) return false;
-  const prev = await fs46.readFile(filePath, "utf8");
+  const filePath = path61.join(root, "CLAUDE.md");
+  if (!await fs47.pathExists(filePath)) return false;
+  const prev = await fs47.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs46.remove(filePath);
+    await fs47.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs46.writeFile(filePath, next, "utf8");
+    await fs47.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs46.pathExists(dir)) return;
+  if (!await fs47.pathExists(dir)) return;
   try {
-    const entries = await fs46.readdir(dir);
-    if (entries.length === 0) await fs46.remove(dir);
+    const entries = await fs47.readdir(dir);
+    if (entries.length === 0) await fs47.remove(dir);
   } catch {
   }
 }
@@ -13251,13 +13588,13 @@ async function backupManagedFilesBeforeUndo(root, managedAbsPaths) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupRoot = hausPath(root, "backups", dirBackupDirName("undo", stamp));
   for (const abs of managedAbsPaths) {
-    if (!await fs46.pathExists(abs)) continue;
-    const rel = path60.relative(root, abs);
-    const backupPath = path60.join(backupRoot, rel);
-    await fs46.ensureDir(path60.dirname(backupPath));
-    await fs46.copy(abs, backupPath);
+    if (!await fs47.pathExists(abs)) continue;
+    const rel = path61.relative(root, abs);
+    const backupPath = path61.join(backupRoot, rel);
+    await fs47.ensureDir(path61.dirname(backupPath));
+    await fs47.copy(abs, backupPath);
   }
-  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path60.relative(root, backupRoot)}.`);
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path61.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
   const root = options.root ?? process.cwd();
@@ -13271,7 +13608,7 @@ async function runUndo(options) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path60.relative(root, p));
+  const relTargets = managed.map((p) => path61.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)");
@@ -13297,9 +13634,9 @@ User-owned .claude/ files will be preserved.`
   }
   await backupManagedFilesBeforeUndo(root, managed);
   for (const abs of coreManaged) {
-    if (!await fs46.pathExists(abs)) continue;
-    await fs46.remove(abs);
-    log(`Removed ${path60.relative(root, abs)}`);
+    if (!await fs47.pathExists(abs)) continue;
+    await fs47.remove(abs);
+    log(`Removed ${path61.relative(root, abs)}`);
   }
   for (const { id, existing } of lockRemovable) {
     await deleteTrackedPaths(root, id, existing, { verb: "Removed" }, log);
@@ -13316,8 +13653,8 @@ init_fs();
 init_logger();
 init_paths();
 import crypto4 from "node:crypto";
-import path61 from "node:path";
-import fs47 from "fs-extra";
+import path62 from "node:path";
+import fs48 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false, removePlugins = removeGlobalPlugins } = options;
   const manifest = await readManifest();
@@ -13354,7 +13691,7 @@ async function runUninstall(options = {}) {
     );
   }
   for (const entry of manifest.files) {
-    const exists = fs47.pathExistsSync(entry.destPath);
+    const exists = fs48.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
@@ -13372,23 +13709,24 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs47.remove(entry.destPath);
-    await pruneEmptyDir(path61.dirname(entry.destPath));
+    await fs48.remove(entry.destPath);
+    await pruneEmptyDir(path62.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 = path61.join(globalClaudeDir(), "haus");
+  const hausDir = path62.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs47.pathExistsSync(manifestPath2)) {
-    await fs47.remove(manifestPath2);
+  if (fs48.pathExistsSync(manifestPath2)) {
+    await fs48.remove(manifestPath2);
   }
-  if (fs47.pathExistsSync(hausDir)) {
+  await removeInstallConfig();
+  if (fs48.pathExistsSync(hausDir)) {
     try {
-      const remaining = await fs47.readdir(hausDir);
-      if (remaining.length === 0) await fs47.remove(hausDir);
+      const remaining = await fs48.readdir(hausDir);
+      if (remaining.length === 0) await fs48.remove(hausDir);
     } catch {
     }
   }
@@ -13457,15 +13795,15 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/validate-catalog.ts
-import path63 from "node:path";
+import path64 from "node:path";
 
 // src/catalog/validate-core.ts
 init_forbidden_content();
 init_manifest_item_fields();
 init_path_safety();
 init_validation_rules2();
-import fs48 from "node:fs";
-import path62 from "node:path";
+import fs49 from "node:fs";
+import path63 from "node:path";
 var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
 var ITEM_ID_PATTERN = /^haus\./;
 function auditForbiddenStacks(items) {
@@ -13625,14 +13963,14 @@ function checkRequiredFrontmatter(text, label) {
 }
 function readForAudit(absPath, label, failures) {
   try {
-    return fs48.readFileSync(absPath, "utf8");
+    return fs49.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 = path62.relative(manifestDir, absPath);
+  const rel = path63.relative(manifestDir, absPath);
   const failures = [];
   const text = readForAudit(absPath, `${itemId}: ${rel}`, failures);
   if (text === null) return failures;
@@ -13654,55 +13992,55 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path || !isSafeCatalogPath(item.path)) continue;
-    const absPath = path62.join(manifestDir, item.path);
+    const absPath = path63.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path62.join(absPath, "SKILL.md");
-      if (!fs48.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path62.relative(manifestDir, skillMd)}`);
+      const skillMd = path63.join(absPath, "SKILL.md");
+      if (!fs49.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path63.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}: ${path62.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path63.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs48.existsSync(absPath)) {
+      if (!fs49.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const rel = path62.relative(manifestDir, absPath);
+      const rel = path63.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 (!fs48.existsSync(absPath)) {
+      if (!fs49.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 (!fs48.existsSync(absPath)) {
+      if (!fs49.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
-      const rel = path62.relative(manifestDir, absPath);
+      const rel = path63.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 (!fs48.existsSync(absPath)) {
+      if (!fs49.existsSync(absPath)) {
         failures.push(`${item.id}: missing config path ${item.path}`);
       }
     } else if (item.type === "rule") {
-      if (!fs48.existsSync(absPath)) {
+      if (!fs49.existsSync(absPath)) {
         failures.push(`${item.id}: missing rule file ${item.path}`);
       }
     } else if (item.type === "asset") {
-      if (!fs48.existsSync(absPath)) {
+      if (!fs49.existsSync(absPath)) {
         failures.push(`${item.id}: missing asset file ${item.path}`);
       }
     }
@@ -13737,7 +14075,7 @@ function resolveItemType(relPath, pathTypeMap) {
 function walkAllFiles(dir, fn, failures) {
   let entries;
   try {
-    entries = fs48.readdirSync(dir, { withFileTypes: true });
+    entries = fs49.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -13746,7 +14084,7 @@ function walkAllFiles(dir, fn, failures) {
   }
   for (const entry of entries) {
     if (entry.name === ".DS_Store") continue;
-    const full = path62.join(dir, entry.name);
+    const full = path63.join(dir, entry.name);
     if (entry.isDirectory()) walkAllFiles(full, fn, failures);
     else fn(full);
   }
@@ -13770,12 +14108,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 = path62.join(manifestDir, dir);
-    if (!fs48.existsSync(abs)) continue;
+    const abs = path63.join(manifestDir, dir);
+    if (!fs49.existsSync(abs)) continue;
     walkAllFiles(
       abs,
       (file) => {
-        const relPath = path62.relative(manifestDir, file).replace(/\\/g, "/");
+        const relPath = path63.relative(manifestDir, file).replace(/\\/g, "/");
         if (!isPathClaimed(relPath, claimedPaths)) {
           failures.push(`orphaned on disk, claimed by no manifest item: ${relPath}`);
         }
@@ -13788,7 +14126,7 @@ function auditDiskOrphans(manifestDir, items) {
 function walkMd(dir, fn, failures) {
   let entries;
   try {
-    entries = fs48.readdirSync(dir, { withFileTypes: true });
+    entries = fs49.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -13796,7 +14134,7 @@ function walkMd(dir, fn, failures) {
     return;
   }
   for (const entry of entries) {
-    const full = path62.join(dir, entry.name);
+    const full = path63.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn, failures);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -13806,13 +14144,13 @@ function auditMarkdownContent(manifestDir, items) {
   const pathSourceMap = buildItemPathSourceMap(items);
   const pathTypeMap = buildItemPathTypeMap(items);
   for (const dir of ["skills", "agents", "templates", "commands", "sources"]) {
-    const abs = path62.join(manifestDir, dir);
-    if (!fs48.existsSync(abs)) continue;
+    const abs = path63.join(manifestDir, dir);
+    if (!fs49.existsSync(abs)) continue;
     const dirType = DIR_ITEM_TYPE[dir] ?? "";
     walkMd(
       abs,
       (file) => {
-        const rel = path62.relative(manifestDir, file);
+        const rel = path63.relative(manifestDir, file);
         const text = readForAudit(file, rel, failures);
         if (text === null) return;
         const norm = rel.replace(/\\/g, "/");
@@ -13860,8 +14198,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path63.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path63.dirname(abs);
+  const abs = path64.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path64.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -13882,8 +14220,8 @@ init_logger();
 
 // src/workspace/worktree/add.ts
 init_fs();
-import path70 from "node:path";
-import fs52 from "fs-extra";
+import path71 from "node:path";
+import fs53 from "fs-extra";
 
 // src/workspace/worktree/git-worktree.ts
 init_exec();
@@ -14003,13 +14341,13 @@ async function hasUnpushedWork(cwd) {
 }
 
 // src/workspace/worktree/hydrate.ts
-import path66 from "node:path";
-import fs50 from "fs-extra";
+import path67 from "node:path";
+import fs51 from "fs-extra";
 
 // src/workspace/worktree/cow-copy.ts
 init_exec();
-import path64 from "node:path";
-import fs49 from "fs-extra";
+import path65 from "node:path";
+import fs50 from "fs-extra";
 async function getMacFilesystemType(dir) {
   const df = await runCommand("df", ["-P", dir]);
   if (df.exitCode !== 0) return void 0;
@@ -14040,14 +14378,14 @@ async function detectCowStrategy(dir) {
   return "unknown-platform";
 }
 async function cowCopyDir(src, dest) {
-  const srcExists = await fs49.pathExists(src);
+  const srcExists = await fs50.pathExists(src);
   if (!srcExists)
     return { strategy: "unsupported", attempted: false, ok: false, error: "source missing" };
-  const strategy = await detectCowStrategy(path64.dirname(dest));
+  const strategy = await detectCowStrategy(path65.dirname(dest));
   if (strategy === "unsupported" || strategy === "unknown-platform") {
     return { strategy, attempted: false, ok: false };
   }
-  await fs49.ensureDir(path64.dirname(dest));
+  await fs50.ensureDir(path65.dirname(dest));
   const args = strategy === "darwin-clonefile" ? ["-c", "-R", src, dest] : ["-a", "--reflink=always", src, dest];
   const result = await runCommand("cp", args);
   return {
@@ -14061,7 +14399,7 @@ async function cowCopyDir(src, dest) {
 // src/workspace/worktree/install.ts
 init_exec();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import path65 from "node:path";
+import path66 from "node:path";
 import fg7 from "fast-glob";
 function detectInstallPlan(signals) {
   if (signals.hasYarnLock) {
@@ -14082,10 +14420,10 @@ function detectInstallPlan(signals) {
   return { manager: "none" };
 }
 async function computeLockfileSignals(dir) {
-  const hasYarnLock = existsSync3(path65.join(dir, "yarn.lock"));
-  const hasPnpmLock = existsSync3(path65.join(dir, "pnpm-lock.yaml"));
-  const hasPackageLock = existsSync3(path65.join(dir, "package-lock.json"));
-  const hasComposerLock = existsSync3(path65.join(dir, "composer.lock"));
+  const hasYarnLock = existsSync3(path66.join(dir, "yarn.lock"));
+  const hasPnpmLock = existsSync3(path66.join(dir, "pnpm-lock.yaml"));
+  const hasPackageLock = existsSync3(path66.join(dir, "package-lock.json"));
+  const hasComposerLock = existsSync3(path66.join(dir, "composer.lock"));
   const dotnetFiles = await fg7(["**/*.csproj", "**/*.sln"], {
     cwd: dir,
     onlyFiles: true,
@@ -14099,7 +14437,7 @@ async function computeLockfileSignals(dir) {
   });
   const hasDotnetProject = dotnetFiles.length > 0;
   let hasPackageManagerField = false;
-  const pkgPath = path65.join(dir, "package.json");
+  const pkgPath = path66.join(dir, "package.json");
   if (existsSync3(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
@@ -14142,7 +14480,7 @@ function missingYarnrcEnvVars(content2, env) {
   return findRequiredYarnrcEnvVars(content2).filter((name) => env[name] === void 0);
 }
 function missingYarnrcEnvVarsInDir(dir, env) {
-  const yarnrcPath = path65.join(dir, ".yarnrc.yml");
+  const yarnrcPath = path66.join(dir, ".yarnrc.yml");
   if (!existsSync3(yarnrcPath)) return [];
   try {
     return missingYarnrcEnvVars(readFileSync3(yarnrcPath, "utf8"), env);
@@ -14238,13 +14576,13 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
   const start = Date.now();
   const targets = [];
   for (const target of HYDRATION_TARGETS) {
-    const src = path66.join(mainMemberPath, target);
-    const dest = path66.join(worktreeMemberPath, target);
-    if (!await fs50.pathExists(src)) continue;
-    const destExists = await fs50.pathExists(dest);
+    const src = path67.join(mainMemberPath, target);
+    const dest = path67.join(worktreeMemberPath, target);
+    if (!await fs51.pathExists(src)) continue;
+    const destExists = await fs51.pathExists(dest);
     if (!opts.force && destExists) continue;
     if (opts.force && destExists) {
-      await fs50.remove(dest);
+      await fs51.remove(dest);
     }
     const copy = await cowCopyDir(src, dest);
     targets.push({ target, copy });
@@ -14257,11 +14595,11 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
 
 // src/workspace/worktree/local-files.ts
 init_exec();
-import path67 from "node:path";
-import fs51 from "fs-extra";
+import path68 from "node:path";
+import fs52 from "fs-extra";
 var MACHINE_LOCAL_FILES = [
   "docker-compose.local.yml",
-  path67.join(".claude", "settings.local.json")
+  path68.join(".claude", "settings.local.json")
 ];
 async function isTracked(repoRoot, relFile) {
   const gitPath = relFile.replace(/\\/g, "/");
@@ -14271,12 +14609,12 @@ async function isTracked(repoRoot, relFile) {
 async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
   const copied = [];
   for (const rel of MACHINE_LOCAL_FILES) {
-    const src = path67.join(mainMemberPath, rel);
-    if (!await fs51.pathExists(src)) continue;
+    const src = path68.join(mainMemberPath, rel);
+    if (!await fs52.pathExists(src)) continue;
     if (await isTracked(mainMemberPath, rel)) continue;
-    const dest = path67.join(worktreeMemberPath, rel);
-    await fs51.ensureDir(path67.dirname(dest));
-    await fs51.copy(src, dest, { overwrite: true });
+    const dest = path68.join(worktreeMemberPath, rel);
+    await fs52.ensureDir(path68.dirname(dest));
+    await fs52.copy(src, dest, { overwrite: true });
     copied.push(rel);
   }
   return copied;
@@ -14284,15 +14622,15 @@ async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
 
 // src/workspace/worktree/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path68 from "node:path";
+import path69 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(path68.join(workspaceRoot, WORKSPACE_FILE));
-  const hasManifest = existsSync4(path68.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const hasYaml = existsSync4(path69.join(workspaceRoot, WORKSPACE_FILE));
+  const hasManifest = existsSync4(path69.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!hasYaml && !hasManifest) {
     return {
       ok: false,
@@ -14318,10 +14656,10 @@ function selectMembers(members, only) {
 
 // src/workspace/worktree/state.ts
 init_fs();
-import path69 from "node:path";
+import path70 from "node:path";
 var WORKTREE_STATE_FILE = ".haus-worktree.json";
 function worktreesDir(mainRoot) {
-  return path69.join(mainRoot, ".claude", "worktrees");
+  return path70.join(mainRoot, ".claude", "worktrees");
 }
 function isValidWorktreeSlug(slug) {
   if (slug === "" || slug === "." || slug === "..") return false;
@@ -14334,22 +14672,22 @@ function worktreePath(mainRoot, slug) {
       `Invalid worktree slug ${JSON.stringify(slug)} \u2014 slugs may only contain letters, digits, ".", "_", "-" (no path separators, and not "." or "..").`
     );
   }
-  return path69.join(worktreesDir(mainRoot), slug);
+  return path70.join(worktreesDir(mainRoot), slug);
 }
 function slugFromWorktreePath(mainRoot, somePath) {
   const dir = worktreesDir(mainRoot);
-  const prefix = `${dir}${path69.sep}`;
+  const prefix = `${dir}${path70.sep}`;
   if (!somePath.startsWith(prefix)) return void 0;
-  const segment = somePath.slice(prefix.length).split(path69.sep)[0];
+  const segment = somePath.slice(prefix.length).split(path70.sep)[0];
   return segment !== void 0 && segment !== "" ? segment : void 0;
 }
 async function readWorktreeState(worktreeRoot) {
-  const state = await readJson(path69.join(worktreeRoot, WORKTREE_STATE_FILE));
+  const state = await readJson(path70.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(path69.join(worktreeRoot, WORKTREE_STATE_FILE), state);
+  await writeJson(path70.join(worktreeRoot, WORKTREE_STATE_FILE), state);
 }
 
 // src/workspace/worktree/add.ts
@@ -14364,7 +14702,7 @@ async function runAdd(opts) {
   }
   const branch = opts.branch ?? opts.slug;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (await fs52.pathExists(wsWorktreePath)) {
+  if (await fs53.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.`
@@ -14383,7 +14721,7 @@ async function runAdd(opts) {
   const memberResults = [];
   for (const member of selected) {
     const start = Date.now();
-    const memberWorktreePath = path70.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path71.join(wsWorktreePath, member.folder);
     const outcome = await addWorktree(member.absPath, memberWorktreePath, branch, {
       preferDefaultBranchFrom: true
     });
@@ -14413,7 +14751,7 @@ async function runAdd(opts) {
   await mapWithConcurrency(okResults, async (result) => {
     const member = selected.find((m) => m.id === result.member);
     if (!member) return;
-    const memberWorktreePath = path70.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path71.join(wsWorktreePath, member.folder);
     const hydrationStart = Date.now();
     if (opts.hydrate !== false) {
       result.hydration = await hydrateMember(member.absPath, memberWorktreePath);
@@ -14481,17 +14819,17 @@ async function runDryRun(args) {
 // src/workspace/worktree/autohydrate.ts
 import { spawn } from "node:child_process";
 import fsSync from "node:fs";
-import path75 from "node:path";
-import fs54 from "fs-extra";
+import path76 from "node:path";
+import fs55 from "fs-extra";
 
 // src/workspace/worktree/doctor.ts
 import { existsSync as existsSync6 } from "node:fs";
-import path73 from "node:path";
+import path74 from "node:path";
 
 // src/workspace/worktree/hydrate-lock.ts
 init_paths();
-import path71 from "node:path";
-import fs53 from "fs-extra";
+import path72 from "node:path";
+import fs54 from "fs-extra";
 var STALE_LOCK_MS = 30 * 60 * 1e3;
 function locksDir(mainRoot) {
   return hausPath(mainRoot, "locks");
@@ -14508,13 +14846,13 @@ function assertSlug(slug) {
   return slug;
 }
 function hydrateLockPath(mainRoot, slug) {
-  return path71.join(locksDir(mainRoot), `hydrate-${assertSlug(slug)}.lock`);
+  return path72.join(locksDir(mainRoot), `hydrate-${assertSlug(slug)}.lock`);
 }
 function hydrateLogPath(mainRoot, slug) {
-  return path71.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.log`);
+  return path72.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.log`);
 }
 function hydrateLastRunPath(mainRoot, slug) {
-  return path71.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.last.json`);
+  return path72.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.last.json`);
 }
 function defaultIsAlive(pid) {
   try {
@@ -14526,7 +14864,7 @@ function defaultIsAlive(pid) {
 }
 async function readOwnerPid(lockPath) {
   try {
-    const raw = (await fs53.readFile(path71.join(lockPath, "pid"), "utf8")).trim();
+    const raw = (await fs54.readFile(path72.join(lockPath, "pid"), "utf8")).trim();
     if (raw === "") return void 0;
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
@@ -14535,13 +14873,13 @@ async function readOwnerPid(lockPath) {
   }
 }
 async function claim(lockPath, pid) {
-  await fs53.ensureDir(path71.dirname(lockPath));
+  await fs54.ensureDir(path72.dirname(lockPath));
   try {
-    await fs53.mkdir(lockPath);
+    await fs54.mkdir(lockPath);
   } catch {
     return false;
   }
-  await fs53.writeFile(path71.join(lockPath, "pid"), String(pid), "utf8");
+  await fs54.writeFile(path72.join(lockPath, "pid"), String(pid), "utf8");
   return true;
 }
 async function acquireHydrateLock(mainRoot, slug, deps = {}) {
@@ -14560,7 +14898,7 @@ async function acquireHydrateLock(mainRoot, slug, deps = {}) {
     }
     if (alive) return { acquired: false, reason: "live", ownerPid, lockPath };
   } else {
-    const stat = await fs53.stat(lockPath).catch(() => void 0);
+    const stat = await fs54.stat(lockPath).catch(() => void 0);
     if (stat === void 0) {
       return await claim(lockPath, pid) ? { acquired: true, lockPath } : { acquired: false, reason: "live", lockPath };
     }
@@ -14568,18 +14906,18 @@ async function acquireHydrateLock(mainRoot, slug, deps = {}) {
       return { acquired: false, reason: "starting", lockPath };
     }
   }
-  await fs53.remove(lockPath);
+  await fs54.remove(lockPath);
   return await claim(lockPath, pid) ? { acquired: true, lockPath } : { acquired: false, reason: "live", ownerPid, lockPath };
 }
 async function recordHydrateLockOwner(mainRoot, slug, pid) {
-  await fs53.writeFile(path71.join(hydrateLockPath(mainRoot, slug), "pid"), String(pid), "utf8");
+  await fs54.writeFile(path72.join(hydrateLockPath(mainRoot, slug), "pid"), String(pid), "utf8");
 }
 async function releaseHydrateLock(mainRoot, slug) {
-  await fs53.remove(hydrateLockPath(mainRoot, slug));
+  await fs54.remove(hydrateLockPath(mainRoot, slug));
 }
 async function readHydrateLock(mainRoot, slug) {
   const lockPath = hydrateLockPath(mainRoot, slug);
-  const stat = await fs53.stat(lockPath).catch(() => void 0);
+  const stat = await fs54.stat(lockPath).catch(() => void 0);
   if (stat === void 0) return { held: false };
   const ownerPid = await readOwnerPid(lockPath);
   return {
@@ -14592,21 +14930,21 @@ async function readHydrateLock(mainRoot, slug) {
 
 // src/workspace/worktree/orphans.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path72 from "node:path";
+import path73 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 = path72.normalize(entry.path);
-      const marker = `${path72.sep}.claude${path72.sep}worktrees${path72.sep}`;
+      const entryPath = path73.normalize(entry.path);
+      const marker = `${path73.sep}.claude${path73.sep}worktrees${path73.sep}`;
       const idx = entryPath.indexOf(marker);
       if (idx === -1) continue;
       const rest = entryPath.slice(idx + marker.length);
-      const slug = rest.split(path72.sep)[0];
+      const slug = rest.split(path73.sep)[0];
       if (!slug) continue;
-      if (existsSync5(path72.join(wsWorktreesDir, slug))) continue;
+      if (existsSync5(path73.join(wsWorktreesDir, slug))) continue;
       orphans.push({
         repoId: repo.id,
         ownerRepo: repo.absPath,
@@ -14621,7 +14959,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(path73.join(memberPath, marker)));
+  return HYDRATION_MARKERS.some((marker) => existsSync6(path74.join(memberPath, marker)));
 }
 async function runDoctor2() {
   const rootInfo = await resolveRoots();
@@ -14638,7 +14976,7 @@ async function runDoctor2() {
     };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const isWorkspace = existsSync6(path73.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path73.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const isWorkspace = existsSync6(path74.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path74.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!isWorkspace) {
     return {
       isWorkspace: false,
@@ -14654,7 +14992,7 @@ async function runDoctor2() {
     };
   }
   const wsWorktreesDir = worktreesDir(workspaceRoot);
-  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path73.sep}`);
+  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path74.sep}`);
   const inWorkspaceWorktree = rootInfo.isLinkedWorktree && underWorktreesDir;
   const workspaceConfig = await readWorkspaceConfig(workspaceRoot);
   const autoHydrate = workspaceConfig?.worktree?.autoHydrate === true;
@@ -14667,10 +15005,10 @@ async function runDoctor2() {
   let hydrationOwnerPid;
   if (inWorkspaceWorktree) {
     const wtPath = rootInfo.repoRoot;
-    slug = rootInfo.worktreeName ?? path73.basename(wtPath);
+    slug = rootInfo.worktreeName ?? path74.basename(wtPath);
     const state = await readWorktreeState(wtPath);
     for (const member of members) {
-      const memberPath = path73.join(wtPath, member.folder);
+      const memberPath = path74.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;
@@ -14715,7 +15053,7 @@ async function runDoctor2() {
     wsWorktreesDir
   );
   const orphans = orphanScan.map(
-    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path73.join(wsWorktreesDir, o.slug)} no longer exists.`
+    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path74.join(wsWorktreesDir, o.slug)} no longer exists.`
   );
   if (orphans.length > 0) {
     problems.push(...orphans);
@@ -14738,7 +15076,7 @@ async function runDoctor2() {
 // src/workspace/worktree/hydrate-command.ts
 init_fs();
 import { existsSync as existsSync7 } from "node:fs";
-import path74 from "node:path";
+import path75 from "node:path";
 async function runHydrateWorktree(opts) {
   const rootInfo = await resolveRoots();
   if (!rootInfo.isGitRepo || !rootInfo.isLinkedWorktree) {
@@ -14749,7 +15087,7 @@ async function runHydrateWorktree(opts) {
   }
   const workspaceRoot = rootInfo.mainRoot;
   const wtPath = rootInfo.repoRoot;
-  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path74.sep}`)) {
+  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path75.sep}`)) {
     return {
       ok: false,
       error: "Current worktree is not one of this workspace's .claude/worktrees/<slug> checkouts."
@@ -14761,13 +15099,13 @@ async function runHydrateWorktree(opts) {
     return { ok: false, error: `Unknown --only repo(s): ${unknown.join(", ")}` };
   }
   const state = await readWorktreeState(wtPath);
-  const slug = state?.slug ?? path74.basename(wtPath);
+  const slug = state?.slug ?? path75.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 = path74.join(wtPath, member.folder);
+        const memberPath = path75.join(wtPath, member.folder);
         if (existsSync7(memberPath)) {
           return { member: member.id, folder: member.folder, status: "planned" };
         }
@@ -14788,7 +15126,7 @@ async function runHydrateWorktree(opts) {
   const results = await mapWithConcurrency(
     selected,
     async (member) => {
-      const memberPath = path74.join(wtPath, member.folder);
+      const memberPath = path75.join(wtPath, member.folder);
       let branchAction;
       if (!existsSync7(memberPath)) {
         if (!opts.materialize) {
@@ -14909,7 +15247,7 @@ function defaultSpawnDetached(spec) {
 }
 function appendLog(logPath, line2) {
   try {
-    fsSync.mkdirSync(path75.dirname(logPath), { recursive: true });
+    fsSync.mkdirSync(path76.dirname(logPath), { recursive: true });
     const size = fsSync.statSync(logPath, { throwIfNoEntry: false })?.size ?? 0;
     if (size > LOG_SIZE_CAP_BYTES) {
       fsSync.writeFileSync(logPath, `--- log rotated (exceeded ${LOG_SIZE_CAP_BYTES} bytes) ---
@@ -14924,11 +15262,11 @@ async function consumeLastRunFailure(mainRoot, slug) {
   const file = hydrateLastRunPath(mainRoot, slug);
   let parsed;
   try {
-    parsed = JSON.parse(await fs54.readFile(file, "utf8"));
+    parsed = JSON.parse(await fs55.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
-  await fs54.remove(file).catch(() => void 0);
+  await fs55.remove(file).catch(() => void 0);
   if (parsed && parsed.ok === false) return parsed;
   return void 0;
 }
@@ -15000,7 +15338,7 @@ async function runAutoHydrate(opts = {}, deps = {}) {
       reason: "could not determine the haus CLI entry point to re-invoke"
     };
   }
-  await fs54.ensureDir(logsDir(mainRoot));
+  await fs55.ensureDir(logsDir(mainRoot));
   appendLog(
     logPath,
     `autohydrate: forking hydrate --materialize for "${slug}" (${missingMembers.join(", ")})`
@@ -15069,21 +15407,21 @@ async function runDetachedHydration() {
 async function writeLastRun(mainRoot, slug, ok, failures) {
   const file = hydrateLastRunPath(mainRoot, slug);
   if (ok) {
-    await fs54.remove(file).catch(() => void 0);
+    await fs55.remove(file).catch(() => void 0);
     return;
   }
   const record = { slug, finishedAt: (/* @__PURE__ */ new Date()).toISOString(), ok, failures };
-  await fs54.ensureDir(path75.dirname(file));
-  await fs54.writeJson(file, record, { spaces: 2 }).catch(() => void 0);
+  await fs55.ensureDir(path76.dirname(file));
+  await fs55.writeJson(file, record, { spaces: 2 }).catch(() => void 0);
 }
 
 // src/workspace/worktree/dematerialize.ts
-import path77 from "node:path";
-import fs56 from "fs-extra";
+import path78 from "node:path";
+import fs57 from "fs-extra";
 
 // src/workspace/worktree/member-targets.ts
-import path76 from "node:path";
-import fs55 from "fs-extra";
+import path77 from "node:path";
+import fs56 from "fs-extra";
 function normalizeStateMembers(state, allMembers) {
   return state?.members.map((m) => ({ id: m.id, folder: m.folder, absPath: m.absPath })) ?? allMembers.map((m) => ({ id: m.id, folder: m.folder, absPath: m.absPath }));
 }
@@ -15100,7 +15438,7 @@ function resolveMemberTargets(wsWorktreePath, stateMembers, allMembers) {
     targets.push({
       repo: configMember?.id ?? stateMember.id,
       ownerRepo,
-      path: path76.join(wsWorktreePath, stateMember.folder)
+      path: path77.join(wsWorktreePath, stateMember.folder)
     });
   }
   return { targets, unresolvedDroppedMembers };
@@ -15108,7 +15446,7 @@ function resolveMemberTargets(wsWorktreePath, stateMembers, allMembers) {
 async function filterExistingTargets(targets) {
   const existing = [];
   for (const target of targets) {
-    if (await fs55.pathExists(target.path)) existing.push(target);
+    if (await fs56.pathExists(target.path)) existing.push(target);
   }
   return existing;
 }
@@ -15153,7 +15491,7 @@ async function runDematerialize(opts) {
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
-  if (!await fs56.pathExists(wsWorktreePath)) {
+  if (!await fs57.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const lock = await readHydrateLock(workspaceRoot, slug);
@@ -15186,9 +15524,9 @@ async function runDematerialize(opts) {
   const removed = [];
   const failed = [];
   for (const folder of unresolvedDroppedMembers) {
-    const droppedPath = path77.join(wsWorktreePath, folder);
-    if (await fs56.pathExists(droppedPath)) {
-      await fs56.remove(droppedPath);
+    const droppedPath = path78.join(wsWorktreePath, folder);
+    if (await fs57.pathExists(droppedPath)) {
+      await fs57.remove(droppedPath);
       failed.push({ repo: folder, error: unresolvedDroppedFailureReason() });
     }
   }
@@ -15202,26 +15540,26 @@ async function runDematerialize(opts) {
 }
 
 // src/workspace/worktree/list.ts
-import path78 from "node:path";
-import fs57 from "fs-extra";
+import path79 from "node:path";
+import fs58 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 fs57.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
-  const entries = await fs57.readdir(dir, { withFileTypes: true });
+  if (!await fs58.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
+  const entries = await fs58.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 = path78.join(dir, slug);
+    const wtPath = path79.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 = path78.join(wtPath, m.folder);
-      const materialized = await fs57.pathExists(memberPath);
+      const memberPath = path79.join(wtPath, m.folder);
+      const materialized = await fs58.pathExists(memberPath);
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
       members.push({
         id: m.id,
@@ -15243,23 +15581,23 @@ async function runList2() {
 
 // src/workspace/worktree/reclaim.ts
 import { existsSync as existsSync8 } from "node:fs";
-import path79 from "node:path";
-import fs58 from "fs-extra";
+import path80 from "node:path";
+import fs59 from "fs-extra";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 async function lastTouchedMs(worktreeRoot) {
-  const candidates = [worktreeRoot, path79.join(worktreeRoot, ".haus-worktree.json")];
+  const candidates = [worktreeRoot, path80.join(worktreeRoot, ".haus-worktree.json")];
   try {
-    const dotGit = await fs58.readFile(path79.join(worktreeRoot, ".git"), "utf8");
+    const dotGit = await fs59.readFile(path80.join(worktreeRoot, ".git"), "utf8");
     const match = /^gitdir:\s*(.+)$/m.exec(dotGit);
     if (match?.[1]) {
       const gitdir = match[1].trim();
-      candidates.push(path79.join(gitdir, "HEAD"), path79.join(gitdir, "index"));
+      candidates.push(path80.join(gitdir, "HEAD"), path80.join(gitdir, "index"));
     }
   } catch {
   }
   let newest = 0;
   for (const candidate of candidates) {
-    const stat = await fs58.stat(candidate).catch(() => void 0);
+    const stat = await fs59.stat(candidate).catch(() => void 0);
     if (stat && stat.mtimeMs > newest) newest = stat.mtimeMs;
   }
   return newest;
@@ -15286,7 +15624,7 @@ async function runReclaim(opts = {}) {
   if (!existsSync8(dir)) {
     return { ok: true, dryRun: !opts.write, olderThanDays, candidates: [], reclaimed: 0 };
   }
-  const allEntries = (await fs58.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const allEntries = (await fs59.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   const entries = allEntries.filter((name) => isValidWorktreeSlug(name));
   const unaddressable = allEntries.filter((name) => !isValidWorktreeSlug(name));
   const members = await readMembers(rootInfo);
@@ -15296,17 +15634,17 @@ async function runReclaim(opts = {}) {
   for (const name of unaddressable) {
     candidates.push({
       slug: name,
-      ageDays: (Date.now() - await lastTouchedMs(path79.join(dir, name))) / MS_PER_DAY,
+      ageDays: (Date.now() - await lastTouchedMs(path80.join(dir, name))) / MS_PER_DAY,
       materializedMembers: 0,
       action: "skip",
       reason: "directory name is not a valid worktree slug \u2014 no haus worktree command can address it; remove it by hand if it is debris"
     });
   }
   for (const slug of entries) {
-    const wtPath = path79.join(dir, slug);
+    const wtPath = path80.join(dir, slug);
     const state = await readWorktreeState(wtPath);
     const stateMembers = normalizeStateMembers(state, members);
-    const materialized = stateMembers.filter((m) => existsSync8(path79.join(wtPath, m.folder)));
+    const materialized = stateMembers.filter((m) => existsSync8(path80.join(wtPath, m.folder)));
     const ageDays = (Date.now() - await lastTouchedMs(wtPath)) / MS_PER_DAY;
     const base = { slug, ageDays, materializedMembers: materialized.length };
     if (slug === currentSlug) {
@@ -15367,13 +15705,13 @@ async function runReclaim(opts = {}) {
 }
 
 // src/workspace/worktree/remove.ts
-import fs59 from "fs-extra";
+import fs60 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 fs59.pathExists(wsWorktreePath)) {
+  if (!await fs60.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const state = await readWorktreeState(wsWorktreePath);
@@ -15441,8 +15779,8 @@ async function runRemove2(opts) {
     }
     await pruneWorktrees(workspaceRoot);
   }
-  if (wsRemoveOk && await fs59.pathExists(wsWorktreePath)) {
-    await fs59.remove(wsWorktreePath);
+  if (wsRemoveOk && await fs60.pathExists(wsWorktreePath)) {
+    await fs60.remove(wsWorktreePath);
   }
   return { ok: failed.length === 0, dryRun: false, slug: opts.slug, removed, failed };
 }
@@ -15903,7 +16241,7 @@ async function runWorktree(action, opts = {}) {
 
 // src/commands/workspace.ts
 import { existsSync as existsSync12, statSync as statSync3 } from "node:fs";
-import path88 from "node:path";
+import path89 from "node:path";
 init_fs();
 init_logger();
 
@@ -15962,7 +16300,7 @@ ${summaries.map(
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync9 } from "node:fs";
-import path81 from "node:path";
+import path82 from "node:path";
 init_logger();
 init_paths();
 
@@ -15970,14 +16308,14 @@ init_paths();
 init_fs();
 init_paths();
 import { readFileSync as readFileSync4 } from "node:fs";
-import path80 from "node:path";
+import path81 from "node:path";
 var MANIFEST_FILE2 = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE2);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync4(path80.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path81.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -16069,7 +16407,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 = path81.resolve(workspaceRoot, repo.path);
+    const repoRoot = path82.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -16142,7 +16480,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         });
         continue;
       }
-      if (!existsSync9(path81.join(workspaceRoot, entry.path))) {
+      if (!existsSync9(path82.join(workspaceRoot, entry.path))) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-copy",
@@ -16188,18 +16526,18 @@ function emit(args) {
 init_logger();
 
 // src/workspace/link-context/link.ts
-import path84 from "node:path";
-import fs62 from "fs-extra";
+import path85 from "node:path";
+import fs63 from "fs-extra";
 init_fs();
 init_logger();
 
 // src/workspace/link-context/plan.ts
-import path83 from "node:path";
-import fs61 from "fs-extra";
+import path84 from "node:path";
+import fs62 from "fs-extra";
 
 // src/workspace/link-context/scan-source.ts
-import path82 from "node:path";
-import fs60 from "fs-extra";
+import path83 from "node:path";
+import fs61 from "fs-extra";
 var ASSET_SUBDIR = {
   skill: "skills",
   agent: "agents",
@@ -16207,36 +16545,36 @@ var ASSET_SUBDIR = {
 };
 async function hasLinkableContext(member) {
   for (const subdir of Object.values(ASSET_SUBDIR)) {
-    if (await fs60.pathExists(path82.join(member.absPath, ".claude", subdir))) return true;
+    if (await fs61.pathExists(path83.join(member.absPath, ".claude", subdir))) return true;
   }
   return false;
 }
 async function collectSkills(member) {
-  const dir = path82.join(member.absPath, ".claude", "skills");
-  if (!await fs60.pathExists(dir)) return [];
-  const names = await fs60.readdir(dir);
+  const dir = path83.join(member.absPath, ".claude", "skills");
+  if (!await fs61.pathExists(dir)) return [];
+  const names = await fs61.readdir(dir);
   const out = [];
   for (const name of [...names].sort()) {
-    const abs = path82.join(dir, name);
-    const stat = await fs60.lstat(abs);
+    const abs = path83.join(dir, name);
+    const stat = await fs61.lstat(abs);
     if (!stat.isDirectory()) continue;
-    if (!await fs60.pathExists(path82.join(abs, "SKILL.md"))) continue;
-    out.push({ type: "skill", name, sourceRelPath: path82.posix.join(".claude", "skills", name) });
+    if (!await fs61.pathExists(path83.join(abs, "SKILL.md"))) continue;
+    out.push({ type: "skill", name, sourceRelPath: path83.posix.join(".claude", "skills", name) });
   }
   return out;
 }
 async function collectFlatMarkdown(member, type) {
   const subdir = ASSET_SUBDIR[type];
-  const dir = path82.join(member.absPath, ".claude", subdir);
-  if (!await fs60.pathExists(dir)) return [];
-  const names = await fs60.readdir(dir);
+  const dir = path83.join(member.absPath, ".claude", subdir);
+  if (!await fs61.pathExists(dir)) return [];
+  const names = await fs61.readdir(dir);
   const out = [];
   for (const fileName of [...names].sort()) {
     if (!fileName.endsWith(".md")) continue;
-    const abs = path82.join(dir, fileName);
-    if (!(await fs60.lstat(abs)).isFile()) continue;
+    const abs = path83.join(dir, fileName);
+    if (!(await fs61.lstat(abs)).isFile()) continue;
     const name = fileName.slice(0, -".md".length);
-    out.push({ type, name, sourceRelPath: path82.posix.join(".claude", subdir, fileName) });
+    out.push({ type, name, sourceRelPath: path83.posix.join(".claude", subdir, fileName) });
   }
   return out;
 }
@@ -16251,9 +16589,9 @@ async function collectSourceAssets(member) {
 
 // src/workspace/link-context/plan.ts
 function repoFolderPrefix(member) {
-  const base = path83.posix.basename(member.folder);
+  const base = path84.posix.basename(member.folder);
   if (base && base !== "." && base !== "/") return base;
-  const fromAbs = path83.basename(member.absPath);
+  const fromAbs = path84.basename(member.absPath);
   return fromAbs || member.id;
 }
 function assetKey(type, destKey) {
@@ -16268,7 +16606,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 fs61.pathExists(member.absPath)) {
+    if (!await fs62.pathExists(member.absPath)) {
       skipped.push({ repo: member.id, reason: `not cloned locally (${member.absPath}) \u2014 skipped` });
       continue;
     }
@@ -16310,7 +16648,7 @@ async function buildLinkPlan(members) {
       name: asset.name,
       destKey,
       sourceRelPath: asset.sourceRelPath,
-      sourceAbsPath: path83.join(member.absPath, asset.sourceRelPath),
+      sourceAbsPath: path84.join(member.absPath, asset.sourceRelPath),
       sourceHash
     });
   }
@@ -16321,7 +16659,7 @@ async function buildLinkPlan(members) {
 function destRelPathFor(type, destKey) {
   const subdir = `${type}s`;
   const leaf = type === "skill" ? destKey : `${destKey}.md`;
-  return path84.posix.join(".claude", subdir, leaf);
+  return path85.posix.join(".claude", subdir, leaf);
 }
 async function runLinkContext(workspaceRoot, opts = {}) {
   const write = resolveWriteMode(opts, "preview-by-default").kind === "write";
@@ -16347,17 +16685,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 = path84.join(workspaceRoot, destRel);
+    const destAbs = path85.join(workspaceRoot, destRel);
     if (write) {
-      await fs62.ensureDir(path84.dirname(destAbs));
-      if (await fs62.pathExists(destAbs)) await fs62.remove(destAbs);
-      await fs62.copy(entry.sourceAbsPath, destAbs, {
+      await fs63.ensureDir(path85.dirname(destAbs));
+      if (await fs63.pathExists(destAbs)) await fs63.remove(destAbs);
+      await fs63.copy(entry.sourceAbsPath, destAbs, {
         overwrite: true,
         errorOnExist: false,
         dereference: false,
         filter: (s) => {
           try {
-            return !fs62.lstatSync(s).isSymbolicLink();
+            return !fs63.lstatSync(s).isSymbolicLink();
           } catch {
             return false;
           }
@@ -16386,7 +16724,7 @@ async function runLinkContext(workspaceRoot, opts = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${old.path}`);
         continue;
       }
-      if (await fs62.pathExists(abs)) await fs62.remove(abs);
+      if (await fs63.pathExists(abs)) await fs63.remove(abs);
     }
   }
   if (write) {
@@ -16438,11 +16776,11 @@ async function runWorkspaceLinkContext(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync10, statSync } from "node:fs";
-import path86 from "node:path";
+import path87 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path85 from "node:path";
-import fs63 from "fs-extra";
+import path86 from "node:path";
+import fs64 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -16467,11 +16805,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") : path85.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path86.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
-  const existed = await fs63.pathExists(filePath);
-  const prev = existed ? await fs63.readFile(filePath, "utf8") : "";
+  const existed = await fs64.pathExists(filePath);
+  const prev = existed ? await fs64.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block, WORKSPACE_SENTINELS);
   const printable = displayPath(workspaceRoot, filePath);
@@ -16500,20 +16838,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 init_fs();
 init_logger();
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path86.resolve(start);
+  let dir = path87.resolve(start);
   for (; ; ) {
-    if (existsSync10(path86.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path86.dirname(dir);
-    if (parent === dir) return path86.resolve(start);
+    if (existsSync10(path87.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path87.dirname(dir);
+    if (parent === dir) return path87.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path86.resolve(workspaceRoot, repoPath) === path86.resolve(workspaceRoot);
+  return path87.resolve(workspaceRoot, repoPath) === path87.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path86.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path87.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -16540,7 +16878,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path86.resolve(workspaceRoot, repo.path);
+    const repoRoot = path87.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
     let res;
@@ -16656,7 +16994,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(path86.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path87.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -16712,7 +17050,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) => path86.join(workspaceRoot, rel)));
+        written.push(...linkResult.added.map((rel) => path87.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` : ""}.`
@@ -16745,8 +17083,8 @@ Workspace setup complete: ${ok} ok, ${failed} failed. Wrote ${written.length} fi
 
 // src/commands/workspace/undo.ts
 import { existsSync as existsSync11, statSync as statSync2 } from "node:fs";
-import path87 from "node:path";
-import fs64 from "fs-extra";
+import path88 from "node:path";
+import fs65 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -16776,7 +17114,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   if (options.dryRun) {
     for (const repo of config.repos) {
-      const repoRoot = path87.resolve(workspaceRoot, repo.path);
+      const repoRoot = path88.resolve(workspaceRoot, repo.path);
       log(`
 \u2192 ${repo.name} (${repo.path})`);
       try {
@@ -16797,7 +17135,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
         continue;
       }
-      if (await fs64.pathExists(abs)) {
+      if (await fs65.pathExists(abs)) {
         log(`[dry-run] Would remove ${entry.path} (linked ${entry.type} from ${entry.repo})`);
       }
     }
@@ -16807,12 +17145,12 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       hausPath(workspaceRoot, "WORKSPACE.md")
     ];
     for (const abs of workspaceArtifacts) {
-      if (await fs64.pathExists(abs)) {
-        log(`[dry-run] Would remove ${path87.relative(workspaceRoot, abs)}`);
+      if (await fs65.pathExists(abs)) {
+        log(`[dry-run] Would remove ${path88.relative(workspaceRoot, abs)}`);
       }
     }
-    if (!await fs64.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
-      const claudeMd = await readText(path87.join(workspaceRoot, "CLAUDE.md"));
+    if (!await fs65.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
+      const claudeMd = await readText(path88.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");
       }
@@ -16831,7 +17169,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   let anyRepoFailed = false;
   for (const repo of config.repos) {
-    const repoRoot = path87.resolve(workspaceRoot, repo.path);
+    const repoRoot = path88.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -16851,29 +17189,29 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
       continue;
     }
-    if (await fs64.pathExists(abs)) {
-      await fs64.remove(abs);
+    if (await fs65.pathExists(abs)) {
+      await fs65.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 fs64.pathExists(abs)) {
-      await fs64.remove(abs);
-      log(`Removed ${path87.relative(workspaceRoot, abs)}`);
+    if (await fs65.pathExists(abs)) {
+      await fs65.remove(abs);
+      log(`Removed ${path88.relative(workspaceRoot, abs)}`);
     }
   }
   const manifestFile = manifestPath(workspaceRoot);
-  if (await fs64.pathExists(manifestFile)) {
-    await fs64.remove(manifestFile);
-    log(`Removed ${path87.relative(workspaceRoot, manifestFile)}`);
+  if (await fs65.pathExists(manifestFile)) {
+    await fs65.remove(manifestFile);
+    log(`Removed ${path88.relative(workspaceRoot, manifestFile)}`);
   }
   const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
-  if (await fs64.pathExists(workspaceMdPath)) {
-    await fs64.remove(workspaceMdPath);
-    log(`Removed ${path87.relative(workspaceRoot, workspaceMdPath)}`);
+  if (await fs65.pathExists(workspaceMdPath)) {
+    await fs65.remove(workspaceMdPath);
+    log(`Removed ${path88.relative(workspaceRoot, workspaceMdPath)}`);
   } else {
-    const claudeMdPath = path87.join(workspaceRoot, "CLAUDE.md");
+    const claudeMdPath = path88.join(workspaceRoot, "CLAUDE.md");
     if (existsSync11(claudeMdPath)) {
       const prev = await readText(claudeMdPath);
       if (prev?.includes(WORKSPACE_BLOCK_BEGIN)) {
@@ -16882,19 +17220,19 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
           end: WORKSPACE_BLOCK_END
         });
         if (next.length === 0) {
-          await fs64.remove(claudeMdPath);
+          await fs65.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the workspace haus import block).");
         } else {
-          await fs64.writeFile(claudeMdPath, next, "utf8");
+          await fs65.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 fs64.remove(claudeMdPath);
+          await fs65.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the pre-upgrade workspace haus import block).");
         } else {
-          await fs64.writeFile(claudeMdPath, next, "utf8");
+          await fs65.writeFile(claudeMdPath, next, "utf8");
           log(
             "Removed pre-upgrade workspace haus import block from CLAUDE.md (user content preserved)."
           );
@@ -16942,7 +17280,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path88.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path89.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -16964,7 +17302,7 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path88.resolve(workspaceRoot, repo.path);
+    const repoRoot = path89.resolve(workspaceRoot, repo.path);
     try {
       if (!existsSync12(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
@@ -17033,7 +17371,7 @@ init_logger();
 init_paths();
 function cliVersion() {
   try {
-    const pkgPath = path89.join(packageRoot(), "package.json");
+    const pkgPath = path90.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -17043,7 +17381,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path89.join(packageRoot(), "package.json");
+    const pkgPath = path90.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -17137,7 +17475,17 @@ program.command("update").description("Sync the remote catalog cache, refresh th
 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."
 ).option("--json", "Emit machine-readable {doctor, decisions, update, ok}").action((opts) => runCiGate(opts));
-program.command("install").description("Seed ~/.claude/ with Haus-managed skills, agents, and hook settings").option("--dry-run").option("--force").option("--check", "Exit non-zero if any HAUS-MANAGED file is out of date").option("--postinstall", "Run by the npm postinstall hook; prints a plain-language change notice").action(runInstall);
+program.command("install").description("Seed ~/.claude/ with Haus-managed skills, agents, and hook settings").option("--dry-run").option("--force").option("--check", "Exit non-zero if any HAUS-MANAGED file is out of date").option("--postinstall", "Run by the npm postinstall hook; prints a plain-language change notice").addOption(
+  new Option(
+    "--internal",
+    "Install Haus's internal channel too (request pipeline + slack-cowork); remembered per machine (ADR-0100)"
+  ).default(void 0)
+).addOption(
+  new Option(
+    "--no-internal",
+    "Remove the internal channel from this machine and remember that"
+  ).default(void 0)
+).action(runInstall);
 program.command("configs [ids...]").description(
   "Copy catalog config items (ESLint, Prettier) into the project root. Pass item IDs to copy specific items, or omit to copy all available config items."
 ).option("--force", "Overwrite existing files").option("--dry-run", "Preview what would be written without changing anything").option("--root <path>", "Project root (defaults to cwd)", process.cwd()).action(runConfigs);