@haus-tech/haus-workflow 5.0.0 → 5.0.1

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 path90 from "node:path";
+import path91 from "node:path";
 import { Command, Option } from "commander";
 
 // src/commands/apply.ts
@@ -2354,9 +2354,162 @@ function summarizeGitignoredHausDirs(paths) {
   return [...dirs];
 }
 
+// src/claude/migrate-request-state.ts
+init_exec();
+init_paths();
+import path12 from "node:path";
+import fs9 from "fs-extra";
+var LEGACY_REQUEST_DIR = ".haus";
+var LEGACY_REQUEST_STATE_MOVES = [
+  { from: `${LEGACY_REQUEST_DIR}/requests`, to: `${HAUS_DIR}/requests`, keepTracked: false },
+  { from: `${LEGACY_REQUEST_DIR}/request.json`, to: `${HAUS_DIR}/request.json`, keepTracked: true }
+];
+async function isSymlink(abs) {
+  try {
+    return (await fs9.lstat(abs)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function exists(abs) {
+  if (await fs9.pathExists(abs)) return true;
+  return isSymlink(abs);
+}
+async function trackedUnder(root, rel) {
+  try {
+    const result = await runGit(["ls-files", "--", rel], { cwd: root, timeout: 5e3 });
+    if (result.exitCode !== 0) return [];
+    return result.stdout.split("\n").map((line2) => line2.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function runGitStep(root, args, notify) {
+  try {
+    const result = await runGit([...args], { cwd: root, timeout: 5e3 });
+    if (result.exitCode === 0) return true;
+    notify(
+      `Could not run \`git ${args.join(" ")}\`: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+    return false;
+  } catch (error2) {
+    notify(
+      `Could not run \`git ${args.join(" ")}\`: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    return false;
+  }
+}
+async function reconcileIndex(root, move, dryRun, notify) {
+  const tracked = await trackedUnder(root, move.from);
+  if (tracked.length === 0) return;
+  if (dryRun) {
+    notify(
+      move.keepTracked ? `Would stage the move of ${move.from} to ${move.to} in git (${tracked.length} tracked file(s)).` : `Would untrack ${tracked.length} committed file(s) under ${move.from} from git \u2014 request pricing material should never have been committed.`
+    );
+    return;
+  }
+  const removed = await runGitStep(
+    root,
+    ["rm", "--cached", "-r", "--quiet", "--", move.from],
+    notify
+  );
+  if (!removed) return;
+  if (move.keepTracked) {
+    await runGitStep(root, ["add", "--", move.to], notify);
+    notify(
+      `Staged the move of ${move.from} to ${move.to} in git \u2014 it is board configuration and stays tracked. Run \`git status\` to review before committing this change.`
+    );
+    return;
+  }
+  notify(
+    `Untracked ${tracked.length} file(s) under ${move.from} from git \u2014 request pricing material should never have been committed, and \`${move.to}\` is gitignored from here on. Run \`git status\` to review before committing this change.`
+  );
+}
+async function removeEmptyLegacyDir(root, previewedMoves, dryRun, notify) {
+  const legacyAbs = path12.join(root, LEGACY_REQUEST_DIR);
+  if (!await fs9.pathExists(legacyAbs)) return;
+  if (await isSymlink(legacyAbs)) return;
+  try {
+    const remaining = await fs9.readdir(legacyAbs);
+    if (dryRun) {
+      const wouldLeave = new Set(previewedMoves.map((m) => path12.basename(m.from)));
+      if (remaining.some((entry) => !wouldLeave.has(entry))) return;
+      notify(`Would remove the ${LEGACY_REQUEST_DIR}/ directory once the moves above empty it.`);
+      return;
+    }
+    if (remaining.length > 0) return;
+    await fs9.remove(legacyAbs);
+    notify(`Removed the now-empty ${LEGACY_REQUEST_DIR}/ directory.`);
+  } catch (error2) {
+    notify(
+      `Could not remove the empty ${LEGACY_REQUEST_DIR}/ directory: ${error2 instanceof Error ? error2.message : String(error2)}. The request state was migrated successfully \u2014 delete ${LEGACY_REQUEST_DIR}/ by hand.`
+    );
+  }
+}
+async function migrateRequestState(root, dryRun, notify) {
+  const moved = [];
+  const conflicts = [];
+  const failures = [];
+  const legacyAbs = path12.join(root, LEGACY_REQUEST_DIR);
+  if (!await exists(legacyAbs)) return { moved, conflicts, failures };
+  if (await isSymlink(legacyAbs)) {
+    for (const move of LEGACY_REQUEST_STATE_MOVES) {
+      conflicts.push({ ...move, reason: "legacy-dir-is-symlink" });
+    }
+    notify(
+      `Refused to migrate request state: ${LEGACY_REQUEST_DIR}/ is a symlink. Moving through it would relocate the link target's real archive into this repo. Migrate the link's target yourself, replace the link with a real directory, then re-run.`
+    );
+    return { moved, conflicts, failures };
+  }
+  for (const move of LEGACY_REQUEST_STATE_MOVES) {
+    const fromAbs = path12.join(root, move.from);
+    const toAbs = path12.join(root, move.to);
+    if (!await exists(fromAbs)) continue;
+    if (await isSymlink(fromAbs)) {
+      conflicts.push({ ...move, reason: "source-is-symlink" });
+      notify(
+        `Refused to migrate ${move.from} to ${move.to}: ${move.from} is a symlink. Moving the link would leave the real request state outside \`${HAUS_DIR}/\`. Move the link's target yourself, then re-run.`
+      );
+      continue;
+    }
+    if (await exists(toAbs)) {
+      conflicts.push({ ...move, reason: "destination-exists" });
+      notify(
+        `Refused to migrate ${move.from} to ${move.to}: ${move.to} already exists. Two locations hold request state \u2014 reconcile them by hand, then remove ${move.from} so this migration can finish.`
+      );
+      continue;
+    }
+    if (dryRun) {
+      moved.push(move);
+      notify(`Would move ${move.from} to ${move.to} (request state now lives under ${HAUS_DIR}/).`);
+      await reconcileIndex(root, move, true, notify);
+      continue;
+    }
+    const trackedBefore = await trackedUnder(root, move.from);
+    try {
+      await fs9.ensureDir(path12.dirname(toAbs));
+      await fs9.move(fromAbs, toAbs);
+    } catch (error2) {
+      const message2 = error2 instanceof Error ? error2.message : String(error2);
+      failures.push({ ...move, message: message2 });
+      notify(
+        `Could not migrate ${move.from} to ${move.to}: ${message2}. ${move.from} was left in place \u2014 fix the cause and re-run \`haus apply --write\`.`
+      );
+      continue;
+    }
+    moved.push(move);
+    notify(
+      `Moved ${move.from} to ${move.to} \u2014 request state now lives under \`${HAUS_DIR}/\`, where haus's gitignore rules cover it (ADR-0103).`
+    );
+    if (trackedBefore.length > 0) await reconcileIndex(root, move, false, notify);
+  }
+  if (moved.length > 0) await removeEmptyLegacyDir(root, moved, dryRun, notify);
+  return { moved, conflicts, failures };
+}
+
 // src/claude/write-claude-files.ts
-import path26 from "node:path";
-import fs24 from "fs-extra";
+import path27 from "node:path";
+import fs25 from "fs-extra";
 init_ingest_catalog();
 
 // src/catalog/skill-description.ts
@@ -2441,7 +2594,7 @@ function findOrphanedLockEntries(lock, recommendedIds) {
 init_validation_rules2();
 
 // src/scanner/detection.ts
-import path12 from "node:path";
+import path13 from "node:path";
 
 // src/security/sensitive-paths.ts
 var DENY_PATHS = [
@@ -2638,7 +2791,7 @@ function finalizeRoles(registryRoles, deps, files) {
 function collectUnsupportedSignals(files) {
   return [
     ...new Set(
-      files.map((f) => UNSUPPORTED_MARKERS[path12.basename(f)]).filter((s) => Boolean(s))
+      files.map((f) => UNSUPPORTED_MARKERS[path13.basename(f)]).filter((s) => Boolean(s))
     )
   ].sort();
 }
@@ -2721,8 +2874,8 @@ function isSupersededByPlugin(lockId, activePinIds) {
 }
 
 // src/scanner/detect-package-manager.ts
-import path13 from "node:path";
-import fs9 from "fs-extra";
+import path14 from "node:path";
+import fs10 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -2740,16 +2893,16 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs9.existsSync(path13.join(root, "yarn.lock"))) return "yarn";
-  if (fs9.existsSync(path13.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs9.existsSync(path13.join(root, "package-lock.json"))) return "npm";
+  if (fs10.existsSync(path14.join(root, "yarn.lock"))) return "yarn";
+  if (fs10.existsSync(path14.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs10.existsSync(path14.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
 // src/update/hash-installed.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import fg3 from "fast-glob";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 
 // src/claude/haus-managed-header.ts
 function parseHausManagedAttrs(line2) {
@@ -2787,9 +2940,9 @@ function parseHausManagedHeader(line2) {
 }
 
 // src/claude/superpowers-install.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import fg2 from "fast-glob";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 init_logger();
 var SKILL_DEP_ARTIFACTS = ["node_modules/**"];
 var SKILL_DEP_ARTIFACT_DIRS = /* @__PURE__ */ new Set(["node_modules"]);
@@ -2812,34 +2965,34 @@ async function previewInstalledSkill(srcFile, opts) {
   return next === text ? void 0 : Buffer.from(next, "utf8");
 }
 async function readRewritableText(file) {
-  const raw = await fs10.readFile(file);
+  const raw = await fs11.readFile(file);
   const text = raw.toString("utf8");
   return Buffer.from(text, "utf8").equals(raw) ? text : void 0;
 }
 async function composeInstalledDescription(destination, signal) {
-  const skillFile = path14.join(destination, SKILL_ENTRY_FILE);
-  if (!await fs10.pathExists(skillFile)) return;
+  const skillFile = path15.join(destination, SKILL_ENTRY_FILE);
+  if (!await fs11.pathExists(skillFile)) return;
   const text = await readRewritableText(skillFile);
   if (text === void 0) return;
   const composed = rewriteSkillDescription(text, signal);
-  if (composed !== text) await fs10.writeFile(skillFile, composed, "utf8");
+  if (composed !== text) await fs11.writeFile(skillFile, composed, "utf8");
 }
 async function installCatalogSkill(sourcePath, destination, opts) {
   if (opts.dryRun) return;
-  await fs10.ensureDir(path14.dirname(destination));
-  if (await fs10.pathExists(destination)) {
+  await fs11.ensureDir(path15.dirname(destination));
+  if (await fs11.pathExists(destination)) {
     const extra = await extraDestFiles(sourcePath, destination);
     if (extra.length > 0) {
       warn(
         `${destination}: removing ${extra.length} untracked file(s) not present in the catalog source before reinstall: ${extra.join(", ")}`
       );
     }
-    for (const entry of await fs10.readdir(destination)) {
+    for (const entry of await fs11.readdir(destination)) {
       if (SKILL_DEP_ARTIFACT_DIRS.has(entry)) continue;
-      await fs10.remove(path14.join(destination, entry));
+      await fs11.remove(path15.join(destination, entry));
     }
   }
-  await fs10.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+  await fs11.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
   if (opts.description) await composeInstalledDescription(destination, opts.description);
 }
 
@@ -2862,12 +3015,12 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
   const normalized = [...new Set(relPaths.map((p) => p.replace(/\\/g, "/")))].sort();
   const fileDigests = [];
   for (const rel of normalized) {
-    const abs = path15.join(root, rel);
-    if (!await fs11.pathExists(abs)) continue;
-    const stat = followSymlinks ? await fs11.stat(abs) : await fs11.lstat(abs);
+    const abs = path16.join(root, rel);
+    if (!await fs12.pathExists(abs)) continue;
+    const stat = followSymlinks ? await fs12.stat(abs) : await fs12.lstat(abs);
     if (!followSymlinks && stat.isSymbolicLink()) continue;
     if (stat.isFile()) {
-      const body = await fs11.readFile(abs);
+      const body = await fs12.readFile(abs);
       fileDigests.push({ rel, digest: digestFileContent(body) });
       continue;
     }
@@ -2887,10 +3040,10 @@ async function hashInstalledPaths(root, relPaths, opts = {}) {
       ignore: [...SKILL_DEP_ARTIFACTS]
     });
     for (const sub of inner.sort()) {
-      const absFile = path15.join(abs, sub);
-      if (!followSymlinks && (await fs11.lstat(absFile)).isSymbolicLink()) continue;
-      const relFile = path15.join(rel, sub).replace(/\\/g, "/");
-      const body = await fs11.readFile(absFile);
+      const absFile = path16.join(abs, sub);
+      if (!followSymlinks && (await fs12.lstat(absFile)).isSymbolicLink()) continue;
+      const relFile = path16.join(rel, sub).replace(/\\/g, "/");
+      const body = await fs12.readFile(absFile);
       fileDigests.push({ rel: relFile, digest: digestFileContent(body) });
     }
   }
@@ -2929,15 +3082,15 @@ init_logger();
 init_paths();
 
 // src/claude/managed-write.ts
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
 async function writeManagedText(root, filePath, nextText, dryRun, quiet = false) {
   const say = quiet ? () => {
   } : log;
-  const existed = await fs12.pathExists(filePath);
-  const prev = existed ? await fs12.readFile(filePath, "utf8") : "";
+  const existed = await fs13.pathExists(filePath);
+  const prev = existed ? await fs13.readFile(filePath, "utf8") : "";
   const printable = displayPath(root, filePath);
   if (dryRun) {
     if (!existed) {
@@ -3023,19 +3176,19 @@ function buildAllowRules() {
 
 // src/install/settings-merge.ts
 init_fs();
-import path17 from "node:path";
-import fs13 from "fs-extra";
+import path18 from "node:path";
+import fs14 from "fs-extra";
 
 // src/install/manifest.ts
 init_fs();
 init_paths();
-import path16 from "node:path";
+import path17 from "node:path";
 var MANIFEST_SCHEMA = "haus-install-manifest/1";
 function globalClaudeDir() {
   return claudeConfigDir();
 }
 function hausManifestPath() {
-  return path16.join(globalClaudeDir(), "haus", "install-manifest.json");
+  return path17.join(globalClaudeDir(), "haus", "install-manifest.json");
 }
 async function readManifest() {
   return readJson(hausManifestPath());
@@ -3074,7 +3227,7 @@ function buildManifest(source, files, hooks, plugins) {
 // src/install/settings-merge.ts
 init_fs();
 function settingsJsonPath() {
-  return path17.join(globalClaudeDir(), "settings.json");
+  return path18.join(globalClaudeDir(), "settings.json");
 }
 async function readSettings() {
   const filePath = settingsJsonPath();
@@ -3334,7 +3487,7 @@ function stripHausAsk(settings) {
 async function loadHooksFragment(fragmentPath) {
   let raw;
   try {
-    raw = await fs13.readJson(fragmentPath);
+    raw = await fs14.readJson(fragmentPath);
   } catch {
     return [];
   }
@@ -3394,8 +3547,8 @@ function buildDenyRules() {
     if (RUNTIME_ONLY_DENY_COMMANDS.includes(command)) continue;
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path91 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path91) ? `${path91}/**` : path91;
+  for (const path92 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path92) ? `${path92}/**` : path92;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -3485,8 +3638,8 @@ async function applyProjectSettingsMerge(root) {
 
 // src/claude/remove-items.ts
 import crypto2 from "node:crypto";
-import path18 from "node:path";
-import fs14 from "fs-extra";
+import path19 from "node:path";
+import fs15 from "fs-extra";
 init_fs();
 init_paths();
 
@@ -3516,17 +3669,17 @@ function classifyBackupName(name) {
 async function unsafeTrackedPath(root, rel) {
   const abs = resolveContainedPath(root, rel);
   if (abs === null) return "escapes-root";
-  if (!await fs14.pathExists(abs)) {
+  if (!await fs15.pathExists(abs)) {
     try {
-      if ((await fs14.lstat(abs)).isSymbolicLink()) return "symlink";
+      if ((await fs15.lstat(abs)).isSymbolicLink()) return "symlink";
     } catch {
       return null;
     }
     return null;
   }
-  if ((await fs14.lstat(abs)).isSymbolicLink()) return "symlink";
-  const [realAbs, realRoot] = await Promise.all([fs14.realpath(abs), fs14.realpath(root)]);
-  const prefix = realRoot.endsWith(path18.sep) ? realRoot : realRoot + path18.sep;
+  if ((await fs15.lstat(abs)).isSymbolicLink()) return "symlink";
+  const [realAbs, realRoot] = await Promise.all([fs15.realpath(abs), fs15.realpath(root)]);
+  const prefix = realRoot.endsWith(path19.sep) ? realRoot : realRoot + path19.sep;
   if (realAbs !== realRoot && !realAbs.startsWith(prefix)) return "symlink";
   return null;
 }
@@ -3550,8 +3703,8 @@ async function resolveExistingTrackedPaths(root, itemId, relPaths, warnFn, unsaf
       warnFn(`Refusing to touch ${itemId}'s recorded path through a symlink: ${rel}`);
       continue;
     }
-    const abs = path18.resolve(root, rel);
-    if (await fs14.pathExists(abs)) existing.push({ rel, abs });
+    const abs = path19.resolve(root, rel);
+    if (await fs15.pathExists(abs)) existing.push({ rel, abs });
   }
   return existing;
 }
@@ -3569,29 +3722,29 @@ async function backupTrackedPaths(root, absPaths, say, prefix) {
   const stamp = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${crypto2.randomBytes(3).toString("hex")}`;
   const backupRoot = hausPath(root, "backups", dirBackupDirName(prefix, stamp));
   for (const abs of absPaths) {
-    if (!await fs14.pathExists(abs)) continue;
-    const rel = path18.relative(root, abs);
-    const backupPath = path18.join(backupRoot, rel);
-    await fs14.ensureDir(path18.dirname(backupPath));
-    await fs14.copy(abs, backupPath);
+    if (!await fs15.pathExists(abs)) continue;
+    const rel = path19.relative(root, abs);
+    const backupPath = path19.join(backupRoot, rel);
+    await fs15.ensureDir(path19.dirname(backupPath));
+    await fs15.copy(abs, backupPath);
   }
   say(
-    `Backed up ${absPaths.length} path(s) to ${path18.relative(root, backupRoot)} before deleting them.`
+    `Backed up ${absPaths.length} path(s) to ${path19.relative(root, backupRoot)} before deleting them.`
   );
   return backupRoot;
 }
 async function deleteTrackedPaths(root, itemId, existing, { verb, reason }, say) {
   for (const { abs } of existing) {
-    await fs14.remove(abs);
-    await pruneEmptyDir(path18.dirname(abs));
+    await fs15.remove(abs);
+    await pruneEmptyDir(path19.dirname(abs));
     say([verb, reason, displayPath(root, abs)].filter(Boolean).join(" ") + ` (${itemId})`);
   }
 }
 
 // src/claude/skill-dep-install.ts
 init_exec();
-import path19 from "node:path";
-import fs15 from "fs-extra";
+import path20 from "node:path";
+import fs16 from "fs-extra";
 function skillDepInstallCommand(manager) {
   switch (manager) {
     case "npm":
@@ -3628,7 +3781,7 @@ function skillDepInstallCommand(manager) {
 }
 async function hasDeclaredDependencies(dir) {
   try {
-    const raw = await fs15.readFile(path19.join(dir, "package.json"), "utf8");
+    const raw = await fs16.readFile(path20.join(dir, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return false;
     const deps = parsed.dependencies;
@@ -3640,16 +3793,16 @@ async function hasDeclaredDependencies(dir) {
 }
 async function realpathOrSelf(target) {
   try {
-    return await fs15.realpath(target);
+    return await fs16.realpath(target);
   } catch {
-    return path19.resolve(target);
+    return path20.resolve(target);
   }
 }
 async function resolveSkillInstallDir(projectRoot, skillDir) {
-  const skillsRoot = await realpathOrSelf(path19.join(projectRoot, ".claude", "skills"));
+  const skillsRoot = await realpathOrSelf(path20.join(projectRoot, ".claude", "skills"));
   const resolved = await realpathOrSelf(skillDir);
-  const rel = path19.relative(skillsRoot, resolved);
-  const contained = rel !== "" && !path19.isAbsolute(rel) && !rel.split(path19.sep).includes("..") && // A directory named exactly `.claude/skills` is the container, not a skill.
+  const rel = path20.relative(skillsRoot, resolved);
+  const contained = rel !== "" && !path20.isAbsolute(rel) && !rel.split(path20.sep).includes("..") && // A directory named exactly `.claude/skills` is the container, not a skill.
   rel.length > 0;
   if (!contained) {
     return { ok: false, reason: `refusing to install outside .claude/skills (${resolved})` };
@@ -3670,8 +3823,8 @@ async function installSkillDependencies(opts, deps = {}) {
   if (!planned.ok) return { status: "skipped", reason: planned.reason };
   const { command, args } = planned.command;
   if (opts.dryRun) return { status: "would-install", command, args };
-  const exists = deps.exists ?? probeCommand;
-  const probe = await exists(command);
+  const exists2 = deps.exists ?? probeCommand;
+  const probe = await exists2(command);
   switch (probe.status) {
     case "available":
       break;
@@ -3685,7 +3838,7 @@ async function installSkillDependencies(opts, deps = {}) {
     default:
       return assertNeverCommandProbe(probe);
   }
-  if (!await fs15.pathExists(contained.dir)) {
+  if (!await fs16.pathExists(contained.dir)) {
     return { status: "skipped", reason: `install directory disappeared (${contained.dir})` };
   }
   const run = deps.run ?? defaultRun;
@@ -3699,7 +3852,7 @@ async function installSkillDependencies(opts, deps = {}) {
 // src/claude/verify-hooks-contract.ts
 init_fs();
 init_paths();
-import fs16 from "fs-extra";
+import fs17 from "fs-extra";
 
 // src/claude/load-hooks.ts
 var CANONICAL_HOOKS = {
@@ -3797,7 +3950,7 @@ async function assertPostApplySettingsHausContract(root) {
 }
 async function verifyProjectSettingsHooksContract(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs16.pathExists(settingsPath)) {
+  if (!await fs17.pathExists(settingsPath)) {
     return {
       ok: true,
       skipped: true,
@@ -3825,10 +3978,10 @@ async function verifyProjectSettingsHooksContract(root) {
 
 // src/claude/write-ci-gate-workflow.ts
 init_logger();
-import path20 from "node:path";
-import fs17 from "fs-extra";
+import path21 from "node:path";
+import fs18 from "fs-extra";
 import YAML from "yaml";
-var CI_GATE_WORKFLOW_REL = path20.join(".github", "workflows", "haus-gate.yml");
+var CI_GATE_WORKFLOW_REL = path21.join(".github", "workflows", "haus-gate.yml");
 var WORKFLOW = `# Written by \`haus init\`. Yours to edit \u2014 haus will not rewrite this file.
 #
 # Runs the checks haus already knows how to run, on every pull request:
@@ -3868,15 +4021,15 @@ jobs:
         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;
+  const dest = path21.join(root, CI_GATE_WORKFLOW_REL);
+  if (await fs18.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;
   }
-  await fs17.ensureDir(path20.dirname(dest));
-  await fs17.writeFile(dest, WORKFLOW, "utf8");
+  await fs18.ensureDir(path21.dirname(dest));
+  await fs18.writeFile(dest, WORKFLOW, "utf8");
   if (!quiet) log(`Wrote ${CI_GATE_WORKFLOW_REL} \u2014 runs \`haus ci-gate\` on every pull request`);
   return dest;
 }
@@ -3895,17 +4048,17 @@ function runScripts(node, found = []) {
   return found;
 }
 async function projectRunsCiGate(root) {
-  const dir = path20.join(root, ".github", "workflows");
+  const dir = path21.join(root, ".github", "workflows");
   let entries;
   try {
-    entries = await fs17.readdir(dir);
+    entries = await fs18.readdir(dir);
   } catch {
     return false;
   }
   for (const entry of entries) {
     if (!/\.ya?ml$/i.test(entry)) continue;
     try {
-      const text = await fs17.readFile(path20.join(dir, entry), "utf8");
+      const text = await fs18.readFile(path21.join(dir, entry), "utf8");
       if (runScripts(YAML.parse(text)).some((script) => CI_GATE_COMMAND.test(script))) return true;
     } catch {
     }
@@ -3914,8 +4067,8 @@ async function projectRunsCiGate(root) {
 }
 
 // src/claude/write-decisions-seed.ts
-import path21 from "node:path";
-import fs18 from "fs-extra";
+import path22 from "node:path";
+import fs19 from "fs-extra";
 
 // library/catalog/decisions-triggers.json
 var decisions_triggers_default = {
@@ -3958,17 +4111,17 @@ Why we chose X \u2014 short, dated, write-once decision log for humans and agent
 | --- | ----- | -------------- | ------ |
 `;
 async function writeDecisionsSeed(root, dryRun, quiet = false) {
-  const decisionsDir = path21.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const readmePath = path21.join(decisionsDir, "README.md");
-  if (await fs18.pathExists(readmePath)) return null;
-  if (!dryRun) await fs18.ensureDir(decisionsDir);
+  const decisionsDir = path22.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const readmePath = path22.join(decisionsDir, "README.md");
+  if (await fs19.pathExists(readmePath)) return null;
+  if (!dryRun) await fs19.ensureDir(decisionsDir);
   await writeManagedText(root, readmePath, SEED_README, dryRun, quiet);
   return readmePath;
 }
 
 // src/claude/write-prettierignore.ts
-import path22 from "node:path";
-import fs19 from "fs-extra";
+import path23 from "node:path";
+import fs20 from "fs-extra";
 var PRETTIERIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var PRETTIERIGNORE_END = "# HAUS:END haus-managed";
 var IGNORED_PATHS = [".haus-workflow/", ".claude/"];
@@ -4036,16 +4189,16 @@ ${block}
 `;
 }
 async function writePrettierIgnore(root, dryRun, quiet = false) {
-  const filePath = path22.join(root, ".prettierignore");
-  const prev = await fs19.pathExists(filePath) ? await fs19.readFile(filePath, "utf8") : "";
+  const filePath = path23.join(root, ".prettierignore");
+  const prev = await fs20.pathExists(filePath) ? await fs20.readFile(filePath, "utf8") : "";
   const next = injectPrettierIgnoreBlock(prev, buildPrettierIgnoreBlock());
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
 }
 
 // src/claude/write-root-claude-md.ts
-import path23 from "node:path";
-import fs20 from "fs-extra";
+import path24 from "node:path";
+import fs21 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
 var WORKSPACE_BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-workspace-imports v=1 -->";
@@ -4123,9 +4276,9 @@ ${block}
 `;
 }
 async function writeRootClaudeMd(root, dryRun, quiet = false) {
-  const filePath = path23.join(root, "CLAUDE.md");
+  const filePath = path24.join(root, "CLAUDE.md");
   const block = buildImportBlock();
-  const prev = await fs20.pathExists(filePath) ? await fs20.readFile(filePath, "utf8") : "";
+  const prev = await fs21.pathExists(filePath) ? await fs21.readFile(filePath, "utf8") : "";
   const next = injectHausBlock(prev, block);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
@@ -4135,13 +4288,13 @@ async function writeRootClaudeMd(root, dryRun, quiet = false) {
 init_fs();
 init_logger();
 init_paths();
-import path25 from "node:path";
-import fs22 from "fs-extra";
+import path26 from "node:path";
+import fs23 from "fs-extra";
 
 // src/claude/derive-workflow-config.ts
 init_fs();
-import path24 from "node:path";
-import fs21 from "fs-extra";
+import path25 from "node:path";
+import fs22 from "fs-extra";
 function binCmd(pm, bin, args) {
   const tail = args ? ` ${args}` : "";
   if (pm === "yarn") return `yarn ${bin}${tail}`;
@@ -4150,7 +4303,7 @@ function binCmd(pm, bin, args) {
 }
 async function deriveWorkflowConfig(root, ctx) {
   const pm = ctx.packageManager === "unknown" ? "npm" : ctx.packageManager;
-  const pkg = await readJson(path24.join(root, "package.json"));
+  const pkg = await readJson(path25.join(root, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = new Set(ctx.dependencies);
   const stacks = Object.values(ctx.detectedStacks ?? {}).flat();
@@ -4160,17 +4313,17 @@ async function deriveWorkflowConfig(root, ctx) {
     return null;
   };
   const hasDep = (name) => deps.has(name);
-  const exists = (rel) => fs21.pathExistsSync(path24.join(root, rel));
+  const exists2 = (rel) => fs22.pathExistsSync(path25.join(root, rel));
   const hasPlaywright = hasDep("@playwright/test") || stacks.includes("playwright");
   const hasCypress = hasDep("cypress");
-  const preCommitTool = exists("lefthook.yml") || exists("lefthook.yaml") ? "lefthook" : exists(".husky") || hasDep("husky") || (scripts.prepare ?? "").includes("husky") ? "husky" : exists(".pre-commit-config.yaml") ? "pre-commit (Python framework)" : null;
+  const preCommitTool = exists2("lefthook.yml") || exists2("lefthook.yaml") ? "lefthook" : exists2(".husky") || hasDep("husky") || (scripts.prepare ?? "").includes("husky") ? "husky" : exists2(".pre-commit-config.yaml") ? "pre-commit (Python framework)" : null;
   return {
     test: script("test") ?? `${pm} test`,
     testE2E: firstScript("test:e2e", "e2e", "test:integration") ?? (hasPlaywright ? binCmd(pm, "playwright", "test") : null) ?? (hasCypress ? binCmd(pm, "cypress", "run") : null),
     preCommitTool,
-    specPath: exists("docs/SPEC.md") ? "docs/SPEC.md" : null,
-    designPath: exists("docs/DESIGN.md") ? "docs/DESIGN.md" : null,
-    uxPath: exists("docs/UX.md") ? "docs/UX.md" : null
+    specPath: exists2("docs/SPEC.md") ? "docs/SPEC.md" : null,
+    designPath: exists2("docs/DESIGN.md") ? "docs/DESIGN.md" : null,
+    uxPath: exists2("docs/UX.md") ? "docs/UX.md" : null
   };
 }
 
@@ -4229,19 +4382,19 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
   } : log;
   const destPath = hausPath(root, "workflow-config.md");
   const printable = displayPath(root, destPath);
-  const exists = await fs22.pathExists(destPath);
-  if (exists && !opts.refill) {
+  const exists2 = await fs23.pathExists(destPath);
+  if (exists2 && !opts.refill) {
     if (dryRun) say(printable + ": exists (project-owned, skipping)");
     return null;
   }
   const ctx = await readJson(hausPath(root, "context-map.json")) ?? {
     ...FALLBACK_CONTEXT,
     root,
-    repoName: path25.basename(root)
+    repoName: path26.basename(root)
   };
   const values = await deriveWorkflowConfig(root, ctx);
-  if (exists) {
-    const current = await fs22.readFile(destPath, "utf8");
+  if (exists2) {
+    const current = await fs23.readFile(destPath, "utf8");
     const refilled = refillContent(current, values);
     if (refilled === current) {
       if (dryRun) say(printable + ": no blank fields to refill");
@@ -4264,7 +4417,7 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
 
 // src/claude/write-workflow.ts
 init_offline();
-import fs23 from "fs-extra";
+import fs24 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -4306,8 +4459,8 @@ async function writeWorkflow(root, pkgVersion, dryRun, force = false, quiet = fa
 ${templateContent}`;
   const destPath = hausPath(root, "WORKFLOW.md");
   const printable = displayPath(root, destPath);
-  if (await fs23.pathExists(destPath)) {
-    const existing = await fs23.readFile(destPath, "utf8");
+  if (await fs24.pathExists(destPath)) {
+    const existing = await fs24.readFile(destPath, "utf8");
     const firstLine = existing.split("\n")[0] ?? "";
     const parsed = parseHausManagedHeader(firstLine);
     if (!parsed) {
@@ -4351,7 +4504,7 @@ ${existingContent}`;
     }
   }
   if (dryRun) {
-    const prev = await fs23.pathExists(destPath) ? await fs23.readFile(destPath, "utf8") : "";
+    const prev = await fs24.pathExists(destPath) ? await fs24.readFile(destPath, "utf8") : "";
     if (!prev) {
       say(createUnifiedDiff(printable, "", next));
     } else {
@@ -4406,14 +4559,14 @@ function decodeIfText(buf) {
   return Buffer.from(asText, "utf8").equals(buf) ? asText : null;
 }
 async function listFilesRecursive2(dir) {
-  if (!await fs24.pathExists(dir)) return [];
+  if (!await fs25.pathExists(dir)) return [];
   const files = [];
   const walk = async (current, relPrefix) => {
-    const names = await fs24.readdir(current);
+    const names = await fs25.readdir(current);
     for (const name of names) {
-      const abs = path26.join(current, name);
+      const abs = path27.join(current, name);
       const rel = relPrefix ? `${relPrefix}/${name}` : name;
-      const stat = await fs24.lstat(abs);
+      const stat = await fs25.lstat(abs);
       if (stat.isSymbolicLink()) {
         warn(`Skipping symlink in dry-run diff preview: ${rel}`);
         continue;
@@ -4430,14 +4583,14 @@ async function listFilesRecursive2(dir) {
 }
 async function logFileDryRunDiff(root, srcFile, destFile, itemId, say, transformed) {
   const printable = displayPath(root, destFile);
-  const nextBuf = transformed ?? await fs24.readFile(srcFile);
-  if (!await fs24.pathExists(destFile)) {
+  const nextBuf = transformed ?? await fs25.readFile(srcFile);
+  if (!await fs25.pathExists(destFile)) {
     say(`${printable}: would create (${itemId})`);
     const nextText2 = decodeIfText(nextBuf);
     if (nextText2 !== null) say(createUnifiedDiff(printable, "", nextText2));
     return;
   }
-  const prevBuf = await fs24.readFile(destFile);
+  const prevBuf = await fs25.readFile(destFile);
   if (prevBuf.equals(nextBuf)) {
     say(`${printable}: unchanged (${itemId})`);
     return;
@@ -4453,28 +4606,28 @@ async function logSkillDryRunDiff(root, sourcePath, destination, itemId, say, in
   const sourceFiles = await listFilesRecursive2(sourcePath);
   const destFiles = await listFilesRecursive2(destination);
   for (const rel of sourceFiles) {
-    const src = path26.join(sourcePath, rel);
+    const src = path27.join(sourcePath, rel);
     const transformed = rel === "SKILL.md" ? await previewInstalledSkill(src, install) : void 0;
-    await logFileDryRunDiff(root, src, path26.join(destination, rel), itemId, say, transformed);
+    await logFileDryRunDiff(root, src, path27.join(destination, rel), itemId, say, transformed);
   }
   const sourceFileSet = new Set(sourceFiles);
   for (const rel of destFiles) {
     if (!sourceFileSet.has(rel)) {
-      say(`${displayPath(root, path26.join(destination, rel))}: would remove (${itemId})`);
+      say(`${displayPath(root, path27.join(destination, rel))}: would remove (${itemId})`);
     }
   }
 }
 async function removeLegacyManagedStub(root, relPathSegments, stub, dryRun, say) {
   const target = claudePath(root, ...relPathSegments);
-  if (!await fs24.pathExists(target)) return;
-  const content2 = await fs24.readFile(target, "utf8");
+  if (!await fs25.pathExists(target)) return;
+  const content2 = await fs25.readFile(target, "utf8");
   if (content2 !== stub && content2 !== `${stub}
 ` && content2 !== `${stub}\r
 `) return;
   if (dryRun) {
     say(`[dry-run] would remove stale ${displayPath(root, target)}`);
   } else {
-    await fs24.remove(target);
+    await fs25.remove(target);
   }
 }
 async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
@@ -4492,7 +4645,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     estimatedTokenReductionPct: 0
   };
   const pkgRoot = packageRoot();
-  const hausVersion2 = (await readJson(path26.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
+  const hausVersion2 = (await readJson(path27.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
   const { items: manifestItems, contentRoot } = await loadCatalogContext(root);
   const coreFiles = [claudePath(root, "settings.json"), claudePath(root, "rules", "haus.md")];
   const rootClaudeMdPath = await writeRootClaudeMd(root, dryRun, opts.quiet);
@@ -4582,11 +4735,11 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   ];
   for (const rel of LEGACY_PRUNED_ARTIFACTS) {
     const legacyPath = hausPath(root, rel);
-    if (await fs24.pathExists(legacyPath)) {
+    if (await fs25.pathExists(legacyPath)) {
       if (dryRun) {
         say(`[dry-run] would remove stale ${displayPath(root, legacyPath)}`);
       } else {
-        await fs24.remove(legacyPath);
+        await fs25.remove(legacyPath);
       }
     }
   }
@@ -4650,7 +4803,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
   let curatedReviewStatusSkips = 0;
   const projectPackageManager = detectPackageManager(
     root,
-    (await readJson(path26.join(root, "package.json")))?.packageManager
+    (await readJson(path27.join(root, "package.json")))?.packageManager
   );
   for (const item of catalogItems) {
     const manifestItem = manifestById.get(item.id);
@@ -4704,7 +4857,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     }
     const sourcePath = catalogItemContentPath(contentRoot, manifestItem);
     const destination = placement.destination;
-    if (await fs24.pathExists(sourcePath)) {
+    if (await fs25.pathExists(sourcePath)) {
       if (dryRun) {
         if (item.type === "skill") {
           await logSkillDryRunDiff(root, sourcePath, destination, item.id, say, {
@@ -4735,13 +4888,13 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
       )) {
         continue;
       } else if (item.type === "skill") {
-        const skillFiles = (await fs24.readdir(sourcePath, { recursive: true })).filter(
+        const skillFiles = (await fs25.readdir(sourcePath, { recursive: true })).filter(
           (f) => typeof f === "string" && f.endsWith(".md")
         );
         let skillValid = true;
         for (const relFile of skillFiles) {
-          const mdPath = path26.join(sourcePath, relFile);
-          const mdContent = await fs24.readFile(mdPath, "utf8");
+          const mdPath = path27.join(sourcePath, relFile);
+          const mdContent = await fs25.readFile(mdPath, "utf8");
           const mdValidation = validateCatalogItem(
             {
               id: manifestItem.id,
@@ -4775,7 +4928,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           say
         );
       } else {
-        const fileContent = await fs24.readFile(sourcePath, "utf8");
+        const fileContent = await fs25.readFile(sourcePath, "utf8");
         const validation = validateCatalogItem(
           {
             id: manifestItem.id,
@@ -4789,11 +4942,11 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
           warn(`Skipping ${item.id}: pre-copy validation failed \u2014 ${validation.reason}`);
           continue;
         }
-        await fs24.ensureDir(path26.dirname(destination));
-        await fs24.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+        await fs25.ensureDir(path27.dirname(destination));
+        await fs25.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
-      const relPaths = [path26.relative(root, destination)];
+      const relPaths = [path27.relative(root, destination)];
       const current = installedPathsByItem.get(item.id) ?? [];
       installedPathsByItem.set(item.id, [...current, ...relPaths]);
       installedIds.add(item.id);
@@ -4916,7 +5069,7 @@ async function hasProtectedUnsafePath(root, relPaths, unsafeByRel) {
   for (const rel of relPaths) {
     const unsafe = unsafeByRel.get(rel) ?? null;
     if (unsafe === "symlink") return true;
-    if (unsafe === "escapes-root" && await fs24.pathExists(path26.resolve(root, rel))) return true;
+    if (unsafe === "escapes-root" && await fs25.pathExists(path27.resolve(root, rel))) return true;
   }
   return false;
 }
@@ -4981,8 +5134,8 @@ async function cleanupMigratedCatalogItems(root, prevLock, migrations, dryRun, q
   void await backupTrackedPaths(root, allAbsPaths, say, "migrate");
   for (const { existing } of toRemove) {
     for (const { abs } of existing) {
-      await fs24.remove(abs);
-      await pruneEmptyDir(path26.dirname(abs));
+      await fs25.remove(abs);
+      await pruneEmptyDir(path27.dirname(abs));
     }
   }
 }
@@ -5040,10 +5193,10 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
       continue;
     }
     const removable = superseded ? existing.filter(({ rel }) => {
-      const isShared = rel.split(path26.sep).join("/") === LEGACY_SUPERPOWERS_SHARED_REL_PATH;
+      const isShared = rel.split(path27.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`
+          `Keeping ${displayPath(root, path27.join(root, rel))} \u2014 a locally-edited superpowers skill still uses it`
         );
         return false;
       }
@@ -5062,8 +5215,8 @@ async function cleanupStaleCatalogItems(root, manifestById, dryRun, quiet, activ
         say(`[dry-run] would remove ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
         continue;
       }
-      await fs24.remove(abs);
-      await pruneEmptyDir(path26.dirname(abs));
+      await fs25.remove(abs);
+      await pruneEmptyDir(path27.dirname(abs));
       say(`Removed ${pruneReason} ${displayPath(root, abs)} (${entry.id})`);
     }
   }
@@ -5117,8 +5270,8 @@ async function pruneOrphanedCatalogItems(root, prevLock, notOrphanedIds, dryRun,
 
 // src/claude/write-gitignore.ts
 init_exec();
-import path27 from "node:path";
-import fs25 from "fs-extra";
+import path28 from "node:path";
+import fs26 from "fs-extra";
 var GITIGNORE_BEGIN = "# HAUS:BEGIN haus-managed v=1";
 var GITIGNORE_END = "# HAUS:END haus-managed";
 var GITIGNORED_ARTIFACT_PATHS = [
@@ -5131,7 +5284,15 @@ var GITIGNORED_ARTIFACT_PATHS = [
   // Hydration locks and the detached hydration log/last-run record (#419): live
   // process state and machine-local diagnostics, meaningless in another checkout.
   ".haus-workflow/locks/",
-  ".haus-workflow/logs/"
+  ".haus-workflow/logs/",
+  // The request pipeline's archive (#472, ADR-0103): per-request pricing material —
+  // specs, impact analyses, scores — written by the request skill, not this CLI. It
+  // lived at `.haus/requests/` behind a hand-added ignore line OUTSIDE this block,
+  // so no client repo ever received the rule; `migrate-request-state.ts` moves it
+  // here precisely so this block can own it. Note `.haus-workflow/request.json`
+  // (the Asana board binding) is deliberately absent: it is shared config, not
+  // machine-local state, and stays tracked like `workflow-config.md`.
+  ".haus-workflow/requests/"
 ];
 function findLineMarker3(content2, marker, from = 0) {
   let idx = content2.indexOf(marker, from);
@@ -5238,15 +5399,15 @@ function injectLinkContextGitignoreBlock(existing) {
   );
 }
 async function writeGitignore(root, dryRun, quiet = false) {
-  const filePath = path27.join(root, ".gitignore");
-  const prev = await fs25.pathExists(filePath) ? await fs25.readFile(filePath, "utf8") : "";
+  const filePath = path28.join(root, ".gitignore");
+  const prev = await fs26.pathExists(filePath) ? await fs26.readFile(filePath, "utf8") : "";
   const next = injectGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
 }
 async function writeLinkContextGitignore(root, dryRun, quiet = false) {
-  const filePath = path27.join(root, ".gitignore");
-  const prev = await fs25.pathExists(filePath) ? await fs25.readFile(filePath, "utf8") : "";
+  const filePath = path28.join(root, ".gitignore");
+  const prev = await fs26.pathExists(filePath) ? await fs26.readFile(filePath, "utf8") : "";
   const next = injectLinkContextGitignoreBlock(prev);
   await writeManagedText(root, filePath, next, dryRun, quiet);
   return filePath;
@@ -5287,7 +5448,7 @@ async function untrackMachineLocalArtifacts(root, dryRun, notify) {
 }
 
 // src/install/ensure-global-plugins.ts
-import path28 from "node:path";
+import path29 from "node:path";
 init_offline();
 init_exec();
 init_fs();
@@ -5526,7 +5687,7 @@ function parseInstalled(stdout2) {
   }
 }
 async function readMarketplaceRefs(configDir) {
-  const settings = await readJson(path28.join(configDir, "settings.json"));
+  const settings = await readJson(path29.join(configDir, "settings.json"));
   const out = {};
   for (const [name, entry] of Object.entries(settings?.extraKnownMarketplaces ?? {})) {
     const ref = entry?.source?.ref;
@@ -5536,7 +5697,7 @@ async function readMarketplaceRefs(configDir) {
 }
 async function readClonedPluginVersion(installLocation) {
   const manifest = await readJson(
-    path28.join(installLocation, ".claude-plugin", "plugin.json")
+    path29.join(installLocation, ".claude-plugin", "plugin.json")
   );
   return typeof manifest?.version === "string" ? manifest.version : void 0;
 }
@@ -5814,26 +5975,26 @@ async function cleanupStaleGlobalPlugins(desired, deps = {}) {
 }
 
 // src/refs/fetch-refs.ts
-import path30 from "node:path";
-import fs27 from "fs-extra";
+import path31 from "node:path";
+import fs28 from "fs-extra";
 
 // src/refs/cache-meta.ts
-import path29 from "node:path";
-import fs26 from "fs-extra";
+import path30 from "node:path";
+import fs27 from "fs-extra";
 var META_FILENAME = "cache-meta.json";
 async function readCacheMeta(cacheDir) {
-  const metaPath = path29.join(cacheDir, META_FILENAME);
+  const metaPath = path30.join(cacheDir, META_FILENAME);
   try {
-    const raw = await fs26.readFile(metaPath, "utf8");
+    const raw = await fs27.readFile(metaPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 async function writeCacheMeta(cacheDir, meta) {
-  await fs26.ensureDir(cacheDir);
-  const metaPath = path29.join(cacheDir, META_FILENAME);
-  await fs26.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await fs27.ensureDir(cacheDir);
+  const metaPath = path30.join(cacheDir, META_FILENAME);
+  await fs27.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
 }
 
 // src/refs/fetch-refs.ts
@@ -5853,8 +6014,8 @@ function isLlmsTxtUrl(ref) {
 async function fetchSingleRef(url, cacheDir, meta) {
   const existing = meta[url];
   const headers = {};
-  const safeFile = existing?.file && existing.file === path30.basename(existing.file);
-  const cachedFileExists = safeFile && await fs27.pathExists(path30.join(cacheDir, existing.file));
+  const safeFile = existing?.file && existing.file === path31.basename(existing.file);
+  const cachedFileExists = safeFile && await fs28.pathExists(path31.join(cacheDir, existing.file));
   if (cachedFileExists) {
     if (existing?.etag) headers["If-None-Match"] = existing.etag;
     if (existing?.lastModified) headers["If-Modified-Since"] = existing.lastModified;
@@ -5865,8 +6026,8 @@ async function fetchSingleRef(url, cacheDir, meta) {
     if (!res.ok) return { result: "failed" };
     const text = await res.text();
     const file = `${urlToSlug(url)}.md`;
-    await fs27.ensureDir(cacheDir);
-    await fs27.writeFile(path30.join(cacheDir, file), text, "utf8");
+    await fs28.ensureDir(cacheDir);
+    await fs28.writeFile(path31.join(cacheDir, file), text, "utf8");
     meta[url] = {
       url,
       etag: res.headers.get("etag") ?? void 0,
@@ -5889,8 +6050,8 @@ async function pruneOrphanedRefs(cacheDir, keepUrls) {
     if (keepUrls.has(url)) continue;
     delete meta[url];
     removed++;
-    const safeFile = typeof entry.file === "string" && entry.file === path30.basename(entry.file);
-    if (safeFile) await fs27.remove(path30.join(cacheDir, entry.file)).catch(() => {
+    const safeFile = typeof entry.file === "string" && entry.file === path31.basename(entry.file);
+    if (safeFile) await fs28.remove(path31.join(cacheDir, entry.file)).catch(() => {
     });
   }
   if (removed > 0) await writeCacheMeta(cacheDir, meta);
@@ -5912,10 +6073,10 @@ async function fetchRefsForItems(items, cacheDir) {
       const outcome = await fetchSingleRef(url, cacheDir, meta);
       if (outcome.result === "fetched") {
         summary.fetched++;
-        summary.cachedFiles[url] = path30.join(cacheDir, outcome.file);
+        summary.cachedFiles[url] = path31.join(cacheDir, outcome.file);
       } else if (outcome.result === "unchanged") {
         summary.unchanged++;
-        if (meta[url]?.file) summary.cachedFiles[url] = path30.join(cacheDir, meta[url].file);
+        if (meta[url]?.file) summary.cachedFiles[url] = path31.join(cacheDir, meta[url].file);
       } else {
         summary.failed++;
         summary.failedUrls.push(url);
@@ -6097,6 +6258,7 @@ async function runApply(options) {
     // Copies a global plugin already provides are removed here (issue #272).
     activePluginIds: await activeGlobalPluginIds(root)
   });
+  await migrateRequestState(root, isDryRun, warn);
   await writeGitignore(root, isDryRun);
   await untrackMachineLocalArtifacts(root, isDryRun, warn);
   if (!isDryRun) {
@@ -6163,8 +6325,8 @@ async function runApply(options) {
 }
 
 // src/commands/backups.ts
-import path31 from "node:path";
-import fs28 from "fs-extra";
+import path32 from "node:path";
+import fs29 from "fs-extra";
 init_logger();
 init_paths();
 
@@ -6231,14 +6393,14 @@ Enter a number (1-${choices.length})`, io);
 // src/commands/backups.ts
 async function listBackups(root) {
   const dir = hausPath(root, "backups");
-  if (!await fs28.pathExists(dir)) return [];
-  const names = await fs28.readdir(dir);
+  if (!await fs29.pathExists(dir)) return [];
+  const names = await fs29.readdir(dir);
   const entries = [];
   for (const name of names) {
     const kind = classifyBackupName(name);
     if (!kind) continue;
-    const absPath = path31.join(dir, name);
-    const stat = await fs28.lstat(absPath);
+    const absPath = path32.join(dir, name);
+    const stat = await fs29.lstat(absPath);
     if (stat.isSymbolicLink()) continue;
     const expectDirectory = kind !== "lock";
     if (stat.isDirectory() !== expectDirectory) continue;
@@ -6277,13 +6439,13 @@ async function runList(root, json) {
   }
 }
 async function isUnsafeWriteTarget(root, target) {
-  const segments = path31.relative(root, target).split(path31.sep).filter(Boolean);
+  const segments = path32.relative(root, target).split(path32.sep).filter(Boolean);
   let current = root;
   for (let i = 0; i < segments.length; i++) {
-    current = path31.join(current, segments[i]);
+    current = path32.join(current, segments[i]);
     const isLastSegment = i === segments.length - 1;
     try {
-      const stat = await fs28.lstat(current);
+      const stat = await fs29.lstat(current);
       if (isLastSegment) {
         if (!stat.isFile()) return true;
       } else if (!stat.isDirectory()) {
@@ -6298,7 +6460,7 @@ async function isUnsafeWriteTarget(root, target) {
 }
 async function lstatIfRegularFile(abs) {
   try {
-    const stat = await fs28.lstat(abs);
+    const stat = await fs29.lstat(abs);
     return stat.isFile() ? stat : null;
   } catch (err) {
     if (err.code === "ENOENT") return null;
@@ -6313,8 +6475,8 @@ async function restoreLockBackup(root, entry, yes, json, dryRun) {
     );
     return { ok: false, restored: 0 };
   }
-  if (await fs28.pathExists(target)) {
-    const targetStat = await fs28.stat(target);
+  if (await fs29.pathExists(target)) {
+    const targetStat = await fs29.stat(target);
     if (targetStat.mtimeMs > entry.mtimeMs) {
       warn(
         `Current haus.lock.json (${new Date(targetStat.mtimeMs).toISOString()}) is newer than backup ${entry.id} (${new Date(entry.mtimeMs).toISOString()}) \u2014 it will be overwritten.`
@@ -6348,7 +6510,7 @@ async function restoreLockBackup(root, entry, yes, json, dryRun) {
     error(`Refusing to restore: ${entry.id} or ${target} changed since being checked.`);
     return { ok: false, restored: 0 };
   }
-  await fs28.copy(entry.absPath, target, { overwrite: true });
+  await fs29.copy(entry.absPath, target, { overwrite: true });
   if (!json) log(`Restored .haus-workflow/haus.lock.json from ${entry.id}.`);
   return { ok: true, restored: 1 };
 }
@@ -6356,10 +6518,10 @@ async function collectFilesRecursive(dir) {
   const files = [];
   const skippedLinks = [];
   const skippedOther = [];
-  const names = await fs28.readdir(dir);
+  const names = await fs29.readdir(dir);
   for (const name of names) {
-    const abs = path31.join(dir, name);
-    const stat = await fs28.lstat(abs);
+    const abs = path32.join(dir, name);
+    const stat = await fs29.lstat(abs);
     if (stat.isSymbolicLink()) {
       skippedLinks.push(abs);
       continue;
@@ -6381,12 +6543,12 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const { files, skippedLinks, skippedOther } = await collectFilesRecursive(entry.absPath);
   if (skippedLinks.length > 0) {
     warn(
-      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path31.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedLinks.length} symlink(s) inside backup ${entry.id} \u2014 never followed: ${skippedLinks.map((abs) => path32.relative(entry.absPath, abs)).join(", ")}`
     );
   }
   if (skippedOther.length > 0) {
     warn(
-      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path31.relative(entry.absPath, abs)).join(", ")}`
+      `Skipped ${skippedOther.length} non-regular file(s) inside backup ${entry.id} (not restorable): ${skippedOther.map((abs) => path32.relative(entry.absPath, abs)).join(", ")}`
     );
   }
   if (files.length === 0) {
@@ -6396,8 +6558,8 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const safeFiles = [];
   const unsafeTargets = [];
   for (const abs of files) {
-    const rel = path31.relative(entry.absPath, abs);
-    const target = path31.join(root, rel);
+    const rel = path32.relative(entry.absPath, abs);
+    const target = path32.join(root, rel);
     if (await isUnsafeWriteTarget(root, target)) unsafeTargets.push(rel);
     else safeFiles.push(abs);
   }
@@ -6414,16 +6576,16 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const vanished = [];
   const toRestore = [];
   for (const abs of safeFiles) {
-    const rel = path31.relative(entry.absPath, abs);
+    const rel = path32.relative(entry.absPath, abs);
     const backupFileStat = await lstatIfRegularFile(abs);
     if (!backupFileStat) {
       vanished.push(rel);
       continue;
     }
     toRestore.push(abs);
-    const target = path31.join(root, rel);
-    if (await fs28.pathExists(target)) {
-      const targetStat = await fs28.stat(target);
+    const target = path32.join(root, rel);
+    if (await fs29.pathExists(target)) {
+      const targetStat = await fs29.stat(target);
       if (targetStat.mtimeMs > backupFileStat.mtimeMs) {
         stale.push({
           rel,
@@ -6451,7 +6613,7 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
     );
   }
   if (dryRun) {
-    const rels = toRestore.map((abs) => path31.relative(entry.absPath, abs));
+    const rels = toRestore.map((abs) => path32.relative(entry.absPath, abs));
     if (!json) {
       log(`[dry-run] Would restore ${rels.length} file(s) from ${entry.id}:`);
       for (const rel of rels) log(`  ${rel}`);
@@ -6477,14 +6639,14 @@ async function restoreDirBackup(root, entry, yes, json, dryRun) {
   let restoredCount = 0;
   const skippedAtWrite = [];
   for (const abs of toRestore) {
-    const rel = path31.relative(entry.absPath, abs);
-    const target = path31.join(root, rel);
+    const rel = path32.relative(entry.absPath, abs);
+    const target = path32.join(root, rel);
     if (!await lstatIfRegularFile(abs) || await isUnsafeWriteTarget(root, target)) {
       skippedAtWrite.push(rel);
       continue;
     }
-    await fs28.ensureDir(path31.dirname(target));
-    await fs28.copy(abs, target, { overwrite: true });
+    await fs29.ensureDir(path32.dirname(target));
+    await fs29.copy(abs, target, { overwrite: true });
     restoredCount++;
   }
   if (skippedAtWrite.length > 0) {
@@ -6565,7 +6727,7 @@ Keeping ${keepCount}.`
   const failed = [];
   for (const entry of removeList) {
     try {
-      await fs28.remove(entry.absPath);
+      await fs29.remove(entry.absPath);
       removed.push(entry.id);
     } catch (err) {
       failed.push({ id: entry.id, message: err instanceof Error ? err.message : String(err) });
@@ -6678,8 +6840,8 @@ init_ingest_catalog();
 init_manifest_format();
 init_path_safety();
 import os2 from "node:os";
-import path32 from "node:path";
-import fs29 from "fs-extra";
+import path33 from "node:path";
+import fs30 from "fs-extra";
 import * as tar from "tar";
 init_fs();
 init_logger();
@@ -6698,7 +6860,7 @@ async function runBundleExport(options) {
     return;
   }
   const cacheDir = getCacheDir();
-  const manifest = await readJson(path32.join(cacheDir, MANIFEST_FILE));
+  const manifest = await readJson(path33.join(cacheDir, MANIFEST_FILE));
   if (!manifest?.items?.length) {
     error("Catalog cache is empty \u2014 run `haus update` on a connected machine first.");
     process.exitCode = 1;
@@ -6709,52 +6871,52 @@ async function runBundleExport(options) {
     catalogRef: typeof manifest.catalogRef === "string" ? manifest.catalogRef : null,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeBundleAsTar(cacheDir, meta, path32.resolve(out));
+  await writeBundleAsTar(cacheDir, meta, path33.resolve(out));
   log(
     `Exported ${manifest.items.length} catalog item(s) to ${out}${meta.catalogRef ? ` (${meta.catalogRef})` : ""}.`
   );
   log("Move it to the disconnected machine and run `haus catalog bundle import <file>`.");
 }
 async function writeBundleAsTar(cacheDir, meta, dest) {
-  const bundleMetaPath = path32.join(cacheDir, BUNDLE_META_FILE);
-  const previousBundleMeta = await fs29.pathExists(bundleMetaPath) ? await fs29.readFile(bundleMetaPath, "utf8") : null;
+  const bundleMetaPath = path33.join(cacheDir, BUNDLE_META_FILE);
+  const previousBundleMeta = await fs30.pathExists(bundleMetaPath) ? await fs30.readFile(bundleMetaPath, "utf8") : null;
   await writeJson(bundleMetaPath, meta);
   try {
-    await fs29.ensureDir(path32.dirname(dest));
+    await fs30.ensureDir(path33.dirname(dest));
     await tar.create({ gzip: true, cwd: cacheDir, file: dest }, ["."]);
   } finally {
-    if (previousBundleMeta === null) await fs29.remove(bundleMetaPath);
-    else await fs29.writeFile(bundleMetaPath, previousBundleMeta, "utf8");
+    if (previousBundleMeta === null) await fs30.remove(bundleMetaPath);
+    else await fs30.writeFile(bundleMetaPath, previousBundleMeta, "utf8");
   }
 }
 function isMarkdownFile(relOrAbsPath) {
   return relOrAbsPath.toLowerCase().endsWith(".md");
 }
 async function listAllFilesUnfiltered(root, current = root) {
-  const entries = await fs29.readdir(current, { withFileTypes: true });
+  const entries = await fs30.readdir(current, { withFileTypes: true });
   const out = [];
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
-    const abs = path32.join(current, entry.name);
+    const abs = path33.join(current, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listAllFilesUnfiltered(root, abs));
     } else if (entry.isFile()) {
-      out.push(path32.relative(root, abs).split(path32.sep).join("/"));
+      out.push(path33.relative(root, abs).split(path33.sep).join("/"));
     }
   }
   return out;
 }
 async function validateStagedItem(item, absPath) {
-  const stat = await fs29.stat(absPath).catch(() => null);
+  const stat = await fs30.stat(absPath).catch(() => null);
   if (!stat) return { ok: true };
   if (stat.isFile()) {
-    const content2 = await fs29.readFile(absPath, "utf8");
+    const content2 = await fs30.readFile(absPath, "utf8");
     return validateCatalogItem(item, content2);
   }
   const files = await listAllFilesUnfiltered(absPath);
   for (const rel of files) {
     if (!isMarkdownFile(rel)) continue;
-    const content2 = await fs29.readFile(path32.join(absPath, rel), "utf8");
+    const content2 = await fs30.readFile(path33.join(absPath, rel), "utf8");
     const verdict = validateCatalogItem(item, content2);
     if (!verdict.ok) return verdict;
   }
@@ -6776,7 +6938,7 @@ async function validateStagedItems(staging, items) {
       continue;
     }
     coveredPaths.push(item.path);
-    if (!await fs29.pathExists(contentPath)) {
+    if (!await fs30.pathExists(contentPath)) {
       if (!isSynthetic) {
         accepted.push(item.id);
         contentlessIds.add(item.id);
@@ -6786,7 +6948,7 @@ async function validateStagedItems(staging, items) {
     const verdict = await validateStagedItem(item, contentPath);
     if (!verdict.ok) {
       warn(`Rejected ${item.id}: ${verdict.reason}`);
-      await fs29.remove(contentPath);
+      await fs30.remove(contentPath);
       if (!isSynthetic) rejected += 1;
       continue;
     }
@@ -6798,30 +6960,30 @@ async function validateStagedItems(staging, items) {
     const covered = coveredPaths.some((p) => rel === p || rel.startsWith(`${p}/`));
     if (!covered) {
       warn(`Refusing staged file outside any catalog item's path: ${rel}`);
-      await fs29.remove(path32.join(staging, rel));
+      await fs30.remove(path33.join(staging, rel));
     }
   }
   await pruneEmptyDirs(staging);
   return { accepted, rejected, contentlessIds };
 }
 async function pruneEmptyDirs(root, dir = root) {
-  const entries = await fs29.readdir(dir, { withFileTypes: true });
+  const entries = await fs30.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      await pruneEmptyDirs(root, path32.join(dir, entry.name));
+      await pruneEmptyDirs(root, path33.join(dir, entry.name));
     }
   }
-  if (dir !== root && (await fs29.readdir(dir)).length === 0) {
-    await fs29.remove(dir);
+  if (dir !== root && (await fs30.readdir(dir)).length === 0) {
+    await fs30.remove(dir);
   }
 }
 async function stripSymlinks(dir) {
   const removed = [];
-  const entries = await fs29.readdir(dir, { withFileTypes: true });
+  const entries = await fs30.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const abs = path32.join(dir, entry.name);
+    const abs = path33.join(dir, entry.name);
     if (entry.isSymbolicLink()) {
-      await fs29.remove(abs);
+      await fs30.remove(abs);
       removed.push(abs);
       continue;
     }
@@ -6833,13 +6995,13 @@ async function stripSymlinks(dir) {
 }
 async function runBundleImport(file, options = {}) {
   const dryRun = Boolean(options.dryRun);
-  const archive = path32.resolve(file);
-  if (!await fs29.pathExists(archive)) {
+  const archive = path33.resolve(file);
+  if (!await fs30.pathExists(archive)) {
     error(`No such bundle: ${file}`);
     process.exitCode = 1;
     return;
   }
-  const staging = await fs29.mkdtemp(path32.join(os2.tmpdir(), "haus-catalog-bundle-import-"));
+  const staging = await fs30.mkdtemp(path33.join(os2.tmpdir(), "haus-catalog-bundle-import-"));
   try {
     await tar.extract({
       file: archive,
@@ -6859,9 +7021,9 @@ async function runBundleImport(file, options = {}) {
     });
     const strippedSymlinks = await stripSymlinks(staging);
     for (const abs of strippedSymlinks) {
-      warn(`Refusing symlink in bundle: ${path32.relative(staging, abs)}`);
+      warn(`Refusing symlink in bundle: ${path33.relative(staging, abs)}`);
     }
-    const manifest = await readJson(path32.join(staging, MANIFEST_FILE));
+    const manifest = await readJson(path33.join(staging, MANIFEST_FILE));
     if (!manifest?.items?.length) {
       error("Bundle contains no catalog manifest \u2014 refusing to import.");
       process.exitCode = 1;
@@ -6872,7 +7034,7 @@ async function runBundleImport(file, options = {}) {
       staging,
       manifest.items
     );
-    const meta = await readJson(path32.join(staging, BUNDLE_META_FILE));
+    const meta = await readJson(path33.join(staging, BUNDLE_META_FILE));
     const label = meta?.catalogRef ?? (meta?.version ? `v${meta.version}` : "unknown ref");
     const installedCount = accepted.length;
     if (dryRun) {
@@ -6895,9 +7057,9 @@ async function runBundleImport(file, options = {}) {
       }
       return;
     }
-    await fs29.ensureDir(getCacheDir());
-    for (const entry of await fs29.readdir(staging)) {
-      await fs29.copy(path32.join(staging, entry), path32.join(getCacheDir(), entry), {
+    await fs30.ensureDir(getCacheDir());
+    for (const entry of await fs30.readdir(staging)) {
+      await fs30.copy(path33.join(staging, entry), path33.join(getCacheDir(), entry), {
         overwrite: true,
         errorOnExist: false
       });
@@ -6914,17 +7076,17 @@ async function runBundleImport(file, options = {}) {
     }
     throw err;
   } finally {
-    await fs29.remove(staging);
+    await fs30.remove(staging);
   }
 }
 
 // src/commands/doctor.ts
-import path48 from "node:path";
-import fs40 from "fs-extra";
+import path49 from "node:path";
+import fs41 from "fs-extra";
 init_manifest_format();
 
 // src/claude/former-install-orphans.ts
-import fs30 from "fs-extra";
+import fs31 from "fs-extra";
 init_path_safety();
 init_paths();
 var toPosix = (value) => value.replace(/\\/g, "/");
@@ -6948,7 +7110,7 @@ async function findOrphanedFormerInstalls(root, items, lockRows) {
     const projectRel = `.claude/${relPath}`;
     if (trackedPaths.has(projectRel) || reported.has(projectRel)) continue;
     const abs = safeJoin(claudePath(root), relPath);
-    if (abs === null || !await fs30.pathExists(abs)) continue;
+    if (abs === null || !await fs31.pathExists(abs)) continue;
     reported.add(projectRel);
     orphans.push({ formerId: entry.formerId, currentId: entry.currentId, relPath: projectRel });
   }
@@ -6956,13 +7118,13 @@ async function findOrphanedFormerInstalls(root, items, lockRows) {
 }
 
 // src/claude/plugin-duplicate-skills.ts
-import fs31 from "node:fs";
-import path33 from "node:path";
+import fs32 from "node:fs";
+import path34 from "node:path";
 init_paths();
 function subdirectoryNames(dir) {
   let entries;
   try {
-    entries = fs31.readdirSync(dir, { withFileTypes: true });
+    entries = fs32.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6971,7 +7133,7 @@ function subdirectoryNames(dir) {
 function isDirectorySymlink(dir, entry) {
   if (!entry.isSymbolicLink()) return false;
   try {
-    return fs31.statSync(path33.join(dir, entry.name)).isDirectory();
+    return fs32.statSync(path34.join(dir, entry.name)).isDirectory();
   } catch {
     return false;
   }
@@ -6989,7 +7151,7 @@ function findPluginDuplicateSkills(root, pluginSkillDirs) {
   return [...duplicates].sort();
 }
 function pluginSkillsDir(installLocation) {
-  return path33.join(installLocation, "skills");
+  return path34.join(installLocation, "skills");
 }
 function reportPluginDuplicates(root, { activePins, marketplaces, lockIds }) {
   if (activePins.length === 0) return { supersededIds: [], untrackedNames: [] };
@@ -7016,7 +7178,7 @@ init_project_pin();
 init_fs();
 init_logger();
 init_paths();
-import fs32 from "fs-extra";
+import fs33 from "fs-extra";
 function normalizeIdList(value) {
   if (!Array.isArray(value)) return [];
   return [
@@ -7044,9 +7206,9 @@ async function readProjectConfigObject(root) {
 async function updateProjectConfig(root, mutate) {
   const file = hausPath(root, PROJECT_CONFIG_FILE);
   let existing = {};
-  if (await fs32.pathExists(file)) {
+  if (await fs33.pathExists(file)) {
     try {
-      const parsed = JSON.parse(await fs32.readFile(file, "utf8"));
+      const parsed = JSON.parse(await fs33.readFile(file, "utf8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         existing = { ...parsed };
       } else {
@@ -7128,9 +7290,9 @@ async function addProjectExcludedIds(root, ids) {
 
 // src/claude/skill-reference-check.ts
 init_paths();
-import path34 from "node:path";
+import path35 from "node:path";
 import fg4 from "fast-glob";
-import fs33 from "fs-extra";
+import fs34 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, "\\$&");
@@ -7303,14 +7465,14 @@ async function findUnresolvedAgentReferences(root, options = {}) {
 }
 async function readInstalledSkillNames(root) {
   const skillsRoot = claudePath(root, "skills");
-  if (!await fs33.pathExists(skillsRoot)) return /* @__PURE__ */ new Set();
-  const entries = await fs33.readdir(skillsRoot, { withFileTypes: true });
+  if (!await fs34.pathExists(skillsRoot)) return /* @__PURE__ */ new Set();
+  const entries = await fs34.readdir(skillsRoot, { withFileTypes: true });
   return new Set(entries.filter((e) => e.isDirectory() && e.name !== "shared").map((e) => e.name));
 }
 async function readInstalledAgentNames(root) {
   const agentsRoot = claudePath(root, "agents");
-  if (!await fs33.pathExists(agentsRoot)) return /* @__PURE__ */ new Set();
-  const entries = await fs33.readdir(agentsRoot, { withFileTypes: true });
+  if (!await fs34.pathExists(agentsRoot)) return /* @__PURE__ */ new Set();
+  const entries = await fs34.readdir(agentsRoot, { withFileTypes: true });
   return new Set(
     entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""))
   );
@@ -7319,14 +7481,14 @@ async function readScannedMarkdown(root) {
   const scanned = [];
   for (const dir of ["skills", "agents", "rules"]) {
     const dirRoot = claudePath(root, dir);
-    if (!await fs33.pathExists(dirRoot)) continue;
+    if (!await fs34.pathExists(dirRoot)) continue;
     const pattern = dir === "skills" ? "*/**/*.md" : "**/*.md";
     const files = await fg4(pattern, { cwd: dirRoot, onlyFiles: true, dot: true });
     for (const rel of files) {
       if (dir === "skills" && rel.startsWith("shared/")) continue;
-      const raw = await fs33.readFile(path34.join(dirRoot, rel), "utf8");
+      const raw = await fs34.readFile(path35.join(dirRoot, rel), "utf8");
       scanned.push({
-        file: path34.posix.join(".claude", dir, rel.split(path34.sep).join("/")),
+        file: path35.posix.join(".claude", dir, rel.split(path35.sep).join("/")),
         lines: stripFencedCodeBlocks(raw).split("\n")
       });
     }
@@ -7336,14 +7498,14 @@ async function readScannedMarkdown(root) {
 
 // src/decisions/doctor.ts
 init_fs();
-import path39 from "node:path";
-import fs37 from "fs-extra";
+import path40 from "node:path";
+import fs38 from "fs-extra";
 
 // src/decisions/check.ts
 init_fs();
 init_paths();
-import path38 from "node:path";
-import fs36 from "fs-extra";
+import path39 from "node:path";
+import fs37 from "fs-extra";
 
 // src/decisions/dep-bump.ts
 var DEP_SECTIONS = [
@@ -7403,7 +7565,7 @@ function isDependencyBumpOnly(beforeText, afterText) {
 // src/decisions/diff.ts
 init_exec();
 init_fs();
-import path35 from "node:path";
+import path36 from "node:path";
 var NUL = String.fromCharCode(0);
 function parseNumstat(output) {
   const fields2 = output.split(NUL);
@@ -7490,7 +7652,7 @@ async function resolvePackageJsonPair(root, file, opts) {
     return { before: before2, after: after2 };
   }
   const before = await readBlob(root, `${range}:${file}`) ?? empty;
-  const after = await readText(path35.join(root, file)) ?? empty;
+  const after = await readText(path36.join(root, file)) ?? empty;
   return { before, after };
 }
 async function collectDiffStats(root, opts) {
@@ -7553,23 +7715,23 @@ function firstMatchingRegex(filePath, patterns) {
 }
 
 // src/decisions/paths.ts
-import path36 from "node:path";
-import fs34 from "fs-extra";
+import path37 from "node:path";
+import fs35 from "fs-extra";
 async function resolveDecisionsDir(root) {
-  const primary = path36.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  if (await fs34.pathExists(primary)) return primary;
-  const legacy = path36.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  if (await fs34.pathExists(legacy)) return legacy;
+  const primary = path37.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  if (await fs35.pathExists(primary)) return primary;
+  const legacy = path37.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  if (await fs35.pathExists(legacy)) return legacy;
   return primary;
 }
 function relativeDecisionPath(decisionsDir, root) {
-  return path36.relative(root, decisionsDir).replace(/\\/g, "/");
+  return path37.relative(root, decisionsDir).replace(/\\/g, "/");
 }
 
 // src/decisions/validate.ts
 init_fs();
-import path37 from "node:path";
-import fs35 from "fs-extra";
+import path38 from "node:path";
+import fs36 from "fs-extra";
 function validateDecisionContent(content2) {
   const errors = [];
   for (const section of DECISIONS_TRIGGERS.requiredSections) {
@@ -7598,14 +7760,14 @@ function decisionNumberFromFile(name) {
   return match?.[1] ?? null;
 }
 async function validateIndexSync(decisionsDir, decisionFiles) {
-  const readmePath = path37.join(decisionsDir, "README.md");
-  if (!await fs35.pathExists(readmePath)) {
+  const readmePath = path38.join(decisionsDir, "README.md");
+  if (!await fs36.pathExists(readmePath)) {
     return ["docs/decisions/README.md is missing"];
   }
   const readme = await readText(readmePath) ?? "";
   const errors = [];
   for (const file of decisionFiles) {
-    const num = decisionNumberFromFile(path37.basename(file));
+    const num = decisionNumberFromFile(path38.basename(file));
     if (num && !indexReferencesNumber(readme, num)) {
       errors.push(`README.md missing index row for ADR-${num}`);
     }
@@ -7705,22 +7867,22 @@ async function checkSatisfaction(input2) {
   const errors = [];
   const decisionsPrefix = `${input2.decisionsRel}/`;
   const newDecisionFiles = input2.changedFiles.filter(
-    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path38.basename(f))
+    (f) => f.startsWith(decisionsPrefix) && isDecisionFileName(path39.basename(f))
   );
   if (newDecisionFiles.length === 0) {
     errors.push(`no new or updated decision under ${input2.decisionsRel}/`);
     return errors;
   }
-  const decisionsDir = path38.join(input2.root, input2.decisionsRel);
+  const decisionsDir = path39.join(input2.root, input2.decisionsRel);
   for (const rel of newDecisionFiles) {
-    const abs = path38.join(input2.root, rel);
+    const abs = path39.join(input2.root, rel);
     const content2 = await readText(abs) ?? "";
     const valid = validateDecisionContent(content2);
     if (!valid.ok) errors.push(...valid.errors.map((e) => `${rel}: ${e}`));
   }
   const indexErrors = await validateIndexSync(
     decisionsDir,
-    newDecisionFiles.map((f) => path38.basename(f))
+    newDecisionFiles.map((f) => path39.basename(f))
   );
   errors.push(...indexErrors);
   return errors;
@@ -7776,8 +7938,8 @@ ${opts.commitMessages ?? ""}`;
     changedFiles: stats.files
   });
   if (satisfactionErrors.length > 0 && decisionsRel !== legacyRel) {
-    const legacyExists = await fs36.pathExists(path38.join(root, legacyRel));
-    if (legacyExists && !await fs36.pathExists(decisionsDir)) {
+    const legacyExists = await fs37.pathExists(path39.join(root, legacyRel));
+    if (legacyExists && !await fs37.pathExists(decisionsDir)) {
       satisfactionErrors = await checkSatisfaction({
         root,
         decisionsRel: legacyRel,
@@ -7799,18 +7961,18 @@ ${opts.commitMessages ?? ""}`;
   return { triggered: true, satisfied: false, reasons, securityTriggered };
 }
 async function listDecisionNumbers(decisionsDir) {
-  if (!await fs36.pathExists(decisionsDir)) return [];
-  const entries = await fs36.readdir(decisionsDir);
+  if (!await fs37.pathExists(decisionsDir)) return [];
+  const entries = await fs37.readdir(decisionsDir);
   return entries.map((name) => decisionNumberFromFile(name)).filter((n) => n != null).map((n) => Number(n));
 }
 
 // src/decisions/doctor.ts
 async function auditDecisionsLayout(root) {
   const findings = [];
-  const primary = path39.join(root, DECISIONS_TRIGGERS.decisionsDir);
-  const legacy = path39.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
-  const hasPrimary = await fs37.pathExists(primary);
-  const hasLegacy = await fs37.pathExists(legacy);
+  const primary = path40.join(root, DECISIONS_TRIGGERS.decisionsDir);
+  const legacy = path40.join(root, DECISIONS_TRIGGERS.legacyDecisionsDir ?? "docs/adr");
+  const hasPrimary = await fs38.pathExists(primary);
+  const hasLegacy = await fs38.pathExists(legacy);
   if (!hasPrimary && hasLegacy) {
     findings.push({
       level: "advisory",
@@ -7823,8 +7985,8 @@ async function auditDecisionsLayout(root) {
   if (!hasPrimary) return findings;
   const decisionsDir = await resolveDecisionsDir(root);
   const rel = relativeDecisionPath(decisionsDir, root);
-  const readmePath = path39.join(decisionsDir, "README.md");
-  if (!await fs37.pathExists(readmePath)) {
+  const readmePath = path40.join(decisionsDir, "README.md");
+  if (!await fs38.pathExists(readmePath)) {
     findings.push({
       level: "advisory",
       line: `- DECISIONS: missing ${rel}/README.md index`,
@@ -7834,7 +7996,7 @@ async function auditDecisionsLayout(root) {
     return findings;
   }
   const readme = await readText(readmePath);
-  const entries = (await fs37.readdir(decisionsDir)).filter(
+  const entries = (await fs38.readdir(decisionsDir)).filter(
     (f) => f.endsWith(".md") && f !== "README.md"
   );
   for (const file of entries) {
@@ -7848,7 +8010,7 @@ async function auditDecisionsLayout(root) {
       });
     }
   }
-  const claude = await readText(path39.join(root, "CLAUDE.md"));
+  const claude = await readText(path40.join(root, "CLAUDE.md"));
   if (claude && !claude.includes(`@${rel}/README.md`)) {
     findings.push({
       level: "advisory",
@@ -7882,14 +8044,14 @@ async function auditDecisionsLayout(root) {
 init_fs();
 init_logger();
 init_paths();
-import path40 from "node:path";
-import fs38 from "fs-extra";
+import path41 from "node:path";
+import fs39 from "fs-extra";
 function manifestPathIn(configDir) {
-  return path40.join(configDir, "haus", "install-manifest.json");
+  return path41.join(configDir, "haus", "install-manifest.json");
 }
 function relativeInside(base, target) {
-  const rel = path40.relative(base, target);
-  if (!rel || rel === ".." || rel.startsWith(`..${path40.sep}`) || path40.isAbsolute(rel)) {
+  const rel = path41.relative(base, target);
+  if (!rel || rel === ".." || rel.startsWith(`..${path41.sep}`) || path41.isAbsolute(rel)) {
     return void 0;
   }
   return rel;
@@ -7901,27 +8063,27 @@ async function sameContent(a, b) {
 async function pruneVacatedDirs(root, vacatedFiles) {
   const dirs = /* @__PURE__ */ new Set();
   for (const file of vacatedFiles) {
-    let dir = path40.dirname(file);
+    let dir = path41.dirname(file);
     while (relativeInside(root, dir) !== void 0) {
       dirs.add(dir);
-      dir = path40.dirname(dir);
+      dir = path41.dirname(dir);
     }
   }
-  const deepestFirst = [...dirs].sort((a, b) => b.split(path40.sep).length - a.split(path40.sep).length);
+  const deepestFirst = [...dirs].sort((a, b) => b.split(path41.sep).length - a.split(path41.sep).length);
   for (const dir of deepestFirst) await pruneEmptyDir(dir);
 }
 async function destinationWritable(dir) {
-  let candidate = path40.resolve(dir);
+  let candidate = path41.resolve(dir);
   for (; ; ) {
-    if (await fs38.pathExists(candidate)) {
+    if (await fs39.pathExists(candidate)) {
       try {
-        await fs38.access(candidate, fs38.constants.W_OK);
+        await fs39.access(candidate, fs39.constants.W_OK);
         return true;
       } catch (err) {
         return err instanceof Error ? err.message : String(err);
       }
     }
-    const parent = path40.dirname(candidate);
+    const parent = path41.dirname(candidate);
     if (parent === candidate) return `no existing ancestor directory for ${dir}`;
     candidate = parent;
   }
@@ -7947,7 +8109,7 @@ async function migrateGlobalConfigDir(options = {}) {
   if (!legacy || !Array.isArray(legacy.files)) {
     return { ...base, reason: "no install manifest under ~/.claude" };
   }
-  if (await fs38.pathExists(manifestPathIn(to))) {
+  if (await fs39.pathExists(manifestPathIn(to))) {
     return { ...base, reason: "an install manifest already exists in the resolved config dir" };
   }
   const writable = await destinationWritable(to);
@@ -7969,15 +8131,15 @@ async function migrateGlobalConfigDir(options = {}) {
       rewritten.push(entry);
       continue;
     }
-    const newDest = path40.join(to, rel);
-    if (!await fs38.pathExists(entry.destPath)) {
+    const newDest = path41.join(to, rel);
+    if (!await fs39.pathExists(entry.destPath)) {
       rewritten.push({ ...entry, destPath: newDest });
       continue;
     }
-    if (await fs38.pathExists(newDest)) {
+    if (await fs39.pathExists(newDest)) {
       if (await sameContent(entry.destPath, newDest)) {
         if (!dryRun) {
-          await fs38.remove(entry.destPath);
+          await fs39.remove(entry.destPath);
           vacated.push(entry.destPath);
         }
         moved.push(newDest);
@@ -7994,7 +8156,7 @@ async function migrateGlobalConfigDir(options = {}) {
       continue;
     }
     try {
-      await fs38.move(entry.destPath, newDest);
+      await fs39.move(entry.destPath, newDest);
       vacated.push(entry.destPath);
       moved.push(newDest);
       rewritten.push({ ...entry, destPath: newDest });
@@ -8019,7 +8181,7 @@ async function migrateGlobalConfigDir(options = {}) {
   }
   try {
     await writeJson(manifestPathIn(to), { ...legacy, files: rewritten });
-    await fs38.remove(legacyManifestPath);
+    await fs39.remove(legacyManifestPath);
     vacated.push(legacyManifestPath);
   } catch (err) {
     return {
@@ -8148,12 +8310,12 @@ function formatPrereqReport(report) {
 }
 
 // src/scanner/read-context.ts
-import path47 from "node:path";
-import fs39 from "fs-extra";
+import path48 from "node:path";
+import fs40 from "fs-extra";
 
 // src/commands/workspace/config.ts
 init_fs();
-import path41 from "node:path";
+import path42 from "node:path";
 import YAML2 from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
@@ -8184,7 +8346,7 @@ function parseWorkspaceConfig(text) {
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
-  return parseWorkspaceConfig(await readText(path41.join(workspaceRoot, WORKSPACE_FILE)));
+  return parseWorkspaceConfig(await readText(path42.join(workspaceRoot, WORKSPACE_FILE)));
 }
 
 // src/scanner/read-context.ts
@@ -8192,7 +8354,7 @@ init_fs();
 init_paths();
 
 // src/workspace/members.ts
-import path42 from "node:path";
+import path43 from "node:path";
 init_fs();
 var REPOS_MANIFEST_FILE = "repos.manifest.json";
 var REPOS_LOCAL_FILE = "repos.local.json";
@@ -8206,14 +8368,14 @@ var MemberConfigError = class extends Error {
 };
 function resolveAbsPath(workspaceRoot, folder, overrides) {
   const override = overrides[folder];
-  if (override) return path42.resolve(workspaceRoot, override);
-  return path42.resolve(workspaceRoot, folder);
+  if (override) return path43.resolve(workspaceRoot, override);
+  return path43.resolve(workspaceRoot, folder);
 }
 function isSelfMember(workspaceRoot, member) {
-  return path42.resolve(member.absPath) === path42.resolve(workspaceRoot);
+  return path43.resolve(member.absPath) === path43.resolve(workspaceRoot);
 }
 async function readPathOverrides(workspaceRoot) {
-  const filePath = path42.join(workspaceRoot, REPOS_LOCAL_FILE);
+  const filePath = path43.join(workspaceRoot, REPOS_LOCAL_FILE);
   const result = await readJsonDetailed(filePath);
   if (result.status === "missing") return {};
   if (result.status === "invalid") throw new MemberConfigError(filePath, "invalid JSON");
@@ -8229,7 +8391,7 @@ async function readPathOverrides(workspaceRoot) {
   return overrides;
 }
 async function readFromWorkspaceYaml(workspaceRoot, overrides) {
-  const filePath = path42.join(workspaceRoot, WORKSPACE_FILE);
+  const filePath = path43.join(workspaceRoot, WORKSPACE_FILE);
   const text = await readText(filePath);
   if (text === void 0) return void 0;
   const config = parseWorkspaceConfig(text);
@@ -8242,7 +8404,7 @@ async function readFromWorkspaceYaml(workspaceRoot, overrides) {
   }));
 }
 async function readFromManifest(workspaceRoot, overrides) {
-  const filePath = path42.join(workspaceRoot, REPOS_MANIFEST_FILE);
+  const filePath = path43.join(workspaceRoot, REPOS_MANIFEST_FILE);
   const result = await readJsonDetailed(filePath);
   if (result.status === "missing") return void 0;
   if (result.status === "invalid") throw new MemberConfigError(filePath, "invalid JSON");
@@ -8284,12 +8446,12 @@ async function readMembers(rootInfo) {
 }
 
 // src/scanner/scan-project.ts
-import path46 from "node:path";
+import path47 from "node:path";
 init_fs();
 
 // src/utils/git-root.ts
 init_exec();
-import path43 from "node:path";
+import path44 from "node:path";
 function fallback(start) {
   return {
     cwd: start,
@@ -8305,11 +8467,11 @@ function fallback(start) {
 async function resolveAbsoluteGitPath(flag, cwd, repoRoot) {
   const withFormat = await runGit(["rev-parse", "--path-format=absolute", flag], { cwd });
   const raw = withFormat.exitCode === 0 ? withFormat.stdout.trim() : "";
-  if (raw && path43.isAbsolute(raw)) return path43.resolve(raw);
+  if (raw && path44.isAbsolute(raw)) return path44.resolve(raw);
   const plain = await runGit(["rev-parse", flag], { cwd });
   const plainRaw = plain.exitCode === 0 ? plain.stdout.trim() : "";
   if (!plainRaw) return "";
-  return path43.isAbsolute(plainRaw) ? path43.resolve(plainRaw) : path43.resolve(repoRoot, plainRaw);
+  return path44.isAbsolute(plainRaw) ? path44.resolve(plainRaw) : path44.resolve(repoRoot, plainRaw);
 }
 async function resolveRoots(start) {
   const cwd = start ?? process.cwd();
@@ -8318,15 +8480,15 @@ async function resolveRoots(start) {
     if (toplevel.exitCode !== 0) return fallback(cwd);
     const toplevelRaw = toplevel.stdout.trim();
     if (!toplevelRaw) return fallback(cwd);
-    const repoRoot = path43.resolve(toplevelRaw);
+    const repoRoot = path44.resolve(toplevelRaw);
     const [gitDir, gitCommonDir] = await Promise.all([
       resolveAbsoluteGitPath("--git-dir", cwd, repoRoot),
       resolveAbsoluteGitPath("--git-common-dir", cwd, repoRoot)
     ]);
     if (!gitDir || !gitCommonDir) return fallback(cwd);
     const isLinkedWorktree = gitDir !== gitCommonDir;
-    const mainRoot = isLinkedWorktree && path43.basename(gitCommonDir) === ".git" ? path43.dirname(gitCommonDir) : repoRoot;
-    const worktreeName = isLinkedWorktree ? path43.basename(gitDir) : null;
+    const mainRoot = isLinkedWorktree && path44.basename(gitCommonDir) === ".git" ? path44.dirname(gitCommonDir) : repoRoot;
+    const worktreeName = isLinkedWorktree ? path44.basename(gitDir) : null;
     return {
       cwd,
       repoRoot,
@@ -8626,7 +8788,7 @@ function runDetection(ctx, rules = STACK_RULES) {
 // src/scanner/render.ts
 init_fs();
 import { readFile } from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 async function buildContentBlob(root, files) {
   const candidates = files.filter(
     (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".php") || f.endsWith(".json") || f.endsWith(".yml") || f.endsWith(".yaml")
@@ -8634,7 +8796,7 @@ async function buildContentBlob(root, files) {
   const slice = candidates.slice(0, 300);
   const parts = await mapWithConcurrency(slice, async (rel) => {
     try {
-      return await readFile(path44.join(root, rel), "utf8");
+      return await readFile(path45.join(root, rel), "utf8");
     } catch {
       return "";
     }
@@ -8643,7 +8805,7 @@ async function buildContentBlob(root, files) {
 }
 
 // src/scanner/workspace-packages.ts
-import path45 from "node:path";
+import path46 from "node:path";
 import fg5 from "fast-glob";
 import YAML3 from "yaml";
 init_fs();
@@ -8651,7 +8813,7 @@ var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
 var MAX_WORKSPACE_MEMBERS = 200;
 function isRepoRelativeGlob(glob) {
   if (glob.length === 0) return false;
-  if (path45.isAbsolute(glob) || glob.startsWith("/")) return false;
+  if (path46.isAbsolute(glob) || glob.startsWith("/")) return false;
   return !glob.split("/").includes("..");
 }
 function stringEntries(value) {
@@ -8676,7 +8838,7 @@ function workspaceGlobsFromPnpmYaml(text) {
 }
 async function readWorkspaceGlobs(root, pkg) {
   const fromPkg = workspaceGlobsFromPackageJson(pkg);
-  const pnpmText = await readText(path45.join(root, PNPM_WORKSPACE_FILE));
+  const pnpmText = await readText(path46.join(root, PNPM_WORKSPACE_FILE));
   const fromPnpm = pnpmText == null ? [] : workspaceGlobsFromPnpmYaml(pnpmText);
   return [.../* @__PURE__ */ new Set([...fromPkg, ...fromPnpm])];
 }
@@ -8697,7 +8859,7 @@ async function collectWorkspaceMemberPackages(root, globs) {
   } catch {
     return [];
   }
-  const rootManifest = path45.resolve(root, "package.json");
+  const rootManifest = path46.resolve(root, "package.json");
   const contained = [
     ...new Set(
       matches.map((rel) => resolveContainedPath(root, rel)).filter((abs) => abs != null && abs !== rootManifest)
@@ -8706,8 +8868,8 @@ async function collectWorkspaceMemberPackages(root, globs) {
   const read = await mapWithConcurrency(contained, async (abs) => {
     const pkg = await readJson(abs);
     if (!isRecord(pkg)) return null;
-    const rel = path45.relative(root, path45.dirname(abs));
-    return { dir: rel.split(path45.sep).join("/"), pkg };
+    const rel = path46.relative(root, path46.dirname(abs));
+    return { dir: rel.split(path46.sep).join("/"), pkg };
   });
   return read.filter((entry) => entry != null);
 }
@@ -8827,8 +8989,8 @@ var SAFE_FILES = [
   "Gemfile"
 ];
 async function scanProject(root, options = {}) {
-  const pkg = await readJson(path46.join(root, "package.json"));
-  const composer = await readJson(path46.join(root, "composer.json"));
+  const pkg = await readJson(path47.join(root, "package.json"));
+  const composer = await readJson(path47.join(root, "composer.json"));
   const files = await listFiles(root, SAFE_FILES);
   const safeFiles = files.filter((f) => !blocked(f));
   const workspaceGlobs = await readWorkspaceGlobs(root, pkg ?? void 0);
@@ -8865,7 +9027,7 @@ async function scanProject(root, options = {}) {
     crossRepoHints.push("Monorepo orchestration detected");
   const unsupportedSignals = collectUnsupportedSignals(safeFiles);
   const detectionStatus = computeDetectionStatus(roles, stacks, unsupportedSignals);
-  const repoNameFallback = pkg?.name ? String(pkg.name) : path46.basename((await resolveRoots(root)).mainRoot);
+  const repoNameFallback = pkg?.name ? String(pkg.name) : path47.basename((await resolveRoots(root)).mainRoot);
   const context = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     repoName: repoNameFallback,
@@ -8889,15 +9051,15 @@ async function scanProject(root, options = {}) {
 // src/scanner/read-context.ts
 async function isCacheFresh(root, cachePath) {
   const markerPaths = [
-    path47.join(root, "package.json"),
-    path47.join(root, "composer.json"),
-    path47.join(root, WORKSPACE_FILE),
-    path47.join(root, REPOS_MANIFEST_FILE)
+    path48.join(root, "package.json"),
+    path48.join(root, "composer.json"),
+    path48.join(root, WORKSPACE_FILE),
+    path48.join(root, REPOS_MANIFEST_FILE)
   ];
-  const cacheStat = await fs39.stat(cachePath);
+  const cacheStat = await fs40.stat(cachePath);
   for (const markerPath of markerPaths) {
-    if (!await fs39.pathExists(markerPath)) continue;
-    const markerStat = await fs39.stat(markerPath);
+    if (!await fs40.pathExists(markerPath)) continue;
+    const markerStat = await fs40.stat(markerPath);
     if (markerStat.mtimeMs > cacheStat.mtimeMs) return false;
   }
   return true;
@@ -9030,7 +9192,7 @@ async function runDoctor(options) {
   } else {
     ok(`- HOOKS OK: ${hooks.message}`);
   }
-  const rootClaudeMdPath = path48.join(root, "CLAUDE.md");
+  const rootClaudeMdPath = path49.join(root, "CLAUDE.md");
   const rootClaudeMdContent = await readText(rootClaudeMdPath);
   if (!rootClaudeMdContent) {
     flag(
@@ -9073,10 +9235,10 @@ async function runDoctor(options) {
         ok("- CLAUDE.md: import block present");
       }
       for (const target of actualTargets) {
-        const resolved = path48.resolve(root, target);
-        const relFromRoot = path48.relative(root, resolved);
-        const escapesRoot = relFromRoot === ".." || relFromRoot.startsWith(`..${path48.sep}`) || path48.isAbsolute(relFromRoot);
-        if (escapesRoot || !await fs40.pathExists(resolved)) {
+        const resolved = path49.resolve(root, target);
+        const relFromRoot = path49.relative(root, resolved);
+        const escapesRoot = relFromRoot === ".." || relFromRoot.startsWith(`..${path49.sep}`) || path49.isAbsolute(relFromRoot);
+        if (escapesRoot || !await fs41.pathExists(resolved)) {
           flag(
             `- CLAUDE.md import: @${target} does not resolve (run \`haus apply --write\`)`,
             `A file CLAUDE.md links to (${target}) is missing, so part of the guidance won't load`,
@@ -9094,7 +9256,7 @@ async function runDoctor(options) {
     );
   }
   const workflowPath = hausPath(root, "WORKFLOW.md");
-  const workflowExists = await fs40.pathExists(workflowPath);
+  const workflowExists = await fs41.pathExists(workflowPath);
   if (!workflowExists) {
     flag(
       "- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)",
@@ -9109,15 +9271,15 @@ async function runDoctor(options) {
       ok("- .haus-workflow/WORKFLOW.md: OK (user-owned)");
     } else {
       const bodyContent = workflowContent.slice(firstLine.length + 1);
-      const cachePath = path48.join(getCacheDir(), "templates/agentic-workflow-standard.md");
-      const bundledPath = path48.join(
+      const cachePath = path49.join(getCacheDir(), "templates/agentic-workflow-standard.md");
+      const bundledPath = path49.join(
         packageRoot(),
         "library",
         "global",
         "templates",
         "agentic-workflow-standard.md"
       );
-      const templatePath = await fs40.pathExists(cachePath) ? cachePath : bundledPath;
+      const templatePath = await fs41.pathExists(cachePath) ? cachePath : bundledPath;
       const templateContent = await readText(templatePath);
       const verdict = checkManagedTamper(bodyContent, managedHeader.hash, templateContent ?? null);
       if (verdict.status === "tampered" || verdict.status === "legacy-diverged") {
@@ -9145,7 +9307,7 @@ async function runDoctor(options) {
     }
   }
   const workflowConfigPath = hausPath(root, "workflow-config.md");
-  const workflowConfigExists = await fs40.pathExists(workflowConfigPath);
+  const workflowConfigExists = await fs41.pathExists(workflowConfigPath);
   if (!workflowConfigExists) {
     flag(
       "- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)",
@@ -9153,7 +9315,7 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const cfg = await fs40.readFile(workflowConfigPath, "utf8");
+    const cfg = await fs41.readFile(workflowConfigPath, "utf8");
     const unfilled = cfg.split("\n").filter((l) => l.includes("<!-- fill in")).length;
     if (unfilled > 0) {
       suggest(
@@ -9165,11 +9327,11 @@ async function runDoctor(options) {
       ok("- .haus-workflow/workflow-config.md: OK (project-owned)");
     }
   }
-  const docsSkillInstalled = await fs40.pathExists(
-    path48.join(root, ".claude", "skills", "writing-documentation", "SKILL.md")
+  const docsSkillInstalled = await fs41.pathExists(
+    path49.join(root, ".claude", "skills", "writing-documentation", "SKILL.md")
   );
   if (docsSkillInstalled) {
-    if (await fs40.pathExists(path48.join(root, "docs", "SUMMARY.md"))) {
+    if (await fs41.pathExists(path49.join(root, "docs", "SUMMARY.md"))) {
       ok("- PROJECT DOCS: OK (docs/SUMMARY.md present)");
     } else {
       suggest(
@@ -9180,7 +9342,7 @@ async function runDoctor(options) {
     }
   }
   if (workflowExists) {
-    const prettierIgnore = await readText(path48.join(root, ".prettierignore")) ?? "";
+    const prettierIgnore = await readText(path49.join(root, ".prettierignore")) ?? "";
     const lines = prettierIgnore.split("\n");
     const missing = IGNORED_PATHS.filter((p) => !prettierIgnoreProtects(lines, p));
     if (missing.length > 0) {
@@ -9328,7 +9490,7 @@ async function runDoctor(options) {
   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") }] : [];
+    return target.ok ? [{ id: item.id, name: path49.basename(target.relPath, ".md") }] : [];
   });
   const STACK_GATE_SKIP_CODES = /* @__PURE__ */ new Set([
     "requires-any-unsatisfied",
@@ -9556,7 +9718,7 @@ async function runDoctor(options) {
       let onDisk = false;
       for (const rel of row.paths ?? []) {
         const abs = resolveContainedPath(root, rel);
-        if (abs !== null && await fs40.pathExists(abs)) {
+        if (abs !== null && await fs41.pathExists(abs)) {
           onDisk = true;
           break;
         }
@@ -9572,7 +9734,7 @@ async function runDoctor(options) {
       );
     }
   }
-  const pkgJson = await readJson(path48.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path49.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -9623,16 +9785,16 @@ async function runDoctor(options) {
 }
 
 // src/commands/update.ts
-import path52 from "node:path";
+import path53 from "node:path";
 init_github_rate_limit();
 init_private_catalog_access();
 
 // src/claude/refresh-project.ts
-import fs41 from "fs-extra";
+import fs42 from "fs-extra";
 init_fs();
 init_paths();
 async function isHausProject(root) {
-  if (await fs41.pathExists(hausPath(root, "recommendation.json"))) return true;
+  if (await fs42.pathExists(hausPath(root, "recommendation.json"))) return true;
   const settings = await readJsonDetailed(claudePath(root, "settings.json"));
   if (settings.status === "ok" && settings.value._haus != null) return true;
   const lock = await readJsonDetailed(hausPath(root, "haus.lock.json"));
@@ -9650,8 +9812,8 @@ async function refreshProjectApply(root) {
 
 // src/install/apply.ts
 import crypto3 from "node:crypto";
-import path50 from "node:path";
-import fs43 from "fs-extra";
+import path51 from "node:path";
+import fs44 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -9760,8 +9922,8 @@ ${content2}`;
 
 // src/install/internal-channel.ts
 init_fs();
-import path49 from "node:path";
-import fs42 from "fs-extra";
+import path50 from "node:path";
+import fs43 from "fs-extra";
 var INSTALL_CONFIG_SCHEMA = "haus-install-config/1";
 var INTERNAL_NAME_PREFIXES = ["request", "slack-cowork"];
 function internalPrefixMatch(name) {
@@ -9778,7 +9940,7 @@ function isInternalAsset(stableId) {
   return internalPrefixMatch(name);
 }
 function installConfigPath() {
-  return path49.join(globalClaudeDir(), "haus", "install-config.json");
+  return path50.join(globalClaudeDir(), "haus", "install-config.json");
 }
 async function readInstallConfig() {
   const raw = await readJson(installConfigPath());
@@ -9795,7 +9957,7 @@ async function writeInstallConfig(config) {
 }
 async function removeInstallConfig() {
   const p = installConfigPath();
-  if (fs42.pathExistsSync(p)) await fs42.remove(p);
+  if (fs43.pathExistsSync(p)) await fs43.remove(p);
 }
 function envOverride() {
   const raw = process.env.HAUS_INTERNAL_CHANNEL?.trim().toLowerCase();
@@ -9825,12 +9987,12 @@ async function pruneEmptyDirsUpward(dirs, stopAt) {
     let dir = start;
     while (dir.startsWith(stopAt) && dir !== stopAt) {
       try {
-        if ((await fs43.readdir(dir)).length > 0) break;
-        await fs43.remove(dir);
+        if ((await fs44.readdir(dir)).length > 0) break;
+        await fs44.remove(dir);
       } catch {
         break;
       }
-      dir = path50.dirname(dir);
+      dir = path51.dirname(dir);
     }
   }
 }
@@ -9839,65 +10001,65 @@ function hashContent(content2) {
 }
 function destFileMissing(destPath) {
   try {
-    return !fs43.statSync(destPath).isFile();
+    return !fs44.statSync(destPath).isFile();
   } catch {
     return true;
   }
 }
 function sourceVersion() {
   try {
-    const pkgPath = path50.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs43.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path51.join(packageRoot(), "package.json");
+    const pkg = JSON.parse(fs44.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
   }
 }
 function globalSrcDir() {
-  return path50.join(packageRoot(), "library", "global");
+  return path51.join(packageRoot(), "library", "global");
 }
 function collectSkillAuxFiles(skillsDir, claudeDir, skillName) {
-  const skillDir = path50.join(skillsDir, skillName);
+  const skillDir = path51.join(skillsDir, skillName);
   const entries = [];
-  for (const rel of fs43.readdirSync(skillDir, { recursive: true })) {
+  for (const rel of fs44.readdirSync(skillDir, { recursive: true })) {
     if (rel === "SKILL.md") continue;
-    const abs = path50.join(skillDir, rel);
-    if (!fs43.statSync(abs).isFile()) continue;
-    const posixRel = rel.split(path50.sep).join("/");
+    const abs = path51.join(skillDir, rel);
+    if (!fs44.statSync(abs).isFile()) continue;
+    const posixRel = rel.split(path51.sep).join("/");
     entries.push({
       stableId: `skill.${skillName}.${posixRel.replace(/\//g, ".")}`,
-      srcRelPath: path50.join("library", "global", "skills", skillName, rel),
-      destPath: path50.join(claudeDir, "skills", skillName, rel)
+      srcRelPath: path51.join("library", "global", "skills", skillName, rel),
+      destPath: path51.join(claudeDir, "skills", skillName, rel)
     });
   }
   return entries;
 }
 function collectFlatChannel(srcDir, claudeDir, dirName, idPrefix) {
   const entries = [];
-  const channelDir = path50.join(srcDir, dirName);
-  if (!fs43.pathExistsSync(channelDir)) return entries;
-  for (const fileName of fs43.readdirSync(channelDir)) {
+  const channelDir = path51.join(srcDir, dirName);
+  if (!fs44.pathExistsSync(channelDir)) return entries;
+  for (const fileName of fs44.readdirSync(channelDir)) {
     if (!fileName.endsWith(".md")) continue;
     const name = fileName.slice(0, -".md".length);
     entries.push({
       stableId: `${idPrefix}.${name}`,
-      srcRelPath: path50.join("library", "global", dirName, fileName),
-      destPath: path50.join(claudeDir, dirName, fileName)
+      srcRelPath: path51.join("library", "global", dirName, fileName),
+      destPath: path51.join(claudeDir, dirName, fileName)
     });
   }
   return entries;
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  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)) {
+  const skillsDir = path51.join(srcDir, "skills");
+  if (fs44.pathExistsSync(skillsDir)) {
+    for (const skillName of fs44.readdirSync(skillsDir)) {
+      const skillFile = path51.join(skillsDir, skillName, "SKILL.md");
+      if (fs44.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path50.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path50.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path51.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path51.join(claudeDir, "skills", skillName, "SKILL.md")
         });
         entries.push(...collectSkillAuxFiles(skillsDir, claudeDir, skillName));
       }
@@ -9937,7 +10099,7 @@ async function applyInstall(options = {}) {
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path50.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path51.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -9966,7 +10128,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs43.pathExistsSync(entry.destPath);
+    const destExists = fs44.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -10006,7 +10168,7 @@ async function applyInstall(options = {}) {
   }
   let mergedSettings;
   if (!check) {
-    const fragmentPath = path50.join(srcDir, "settings-fragments", "hooks.json");
+    const fragmentPath = path51.join(srcDir, "settings-fragments", "hooks.json");
     const fragments = await loadHooksFragment(fragmentPath);
     const settings = await readSettings();
     const { settings: hookSettings, addedIds } = mergeHooks(settings, fragments);
@@ -10026,14 +10188,14 @@ async function applyInstall(options = {}) {
         manifestFiles.push(entry);
         continue;
       }
-      if (!fs43.pathExistsSync(entry.destPath)) continue;
+      if (!fs44.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 fs43.remove(entry.destPath);
-        emptiedDirs.add(path50.dirname(entry.destPath));
+        if (!dryRun) await fs44.remove(entry.destPath);
+        emptiedDirs.add(path51.dirname(entry.destPath));
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -10127,7 +10289,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 path51 from "node:path";
+import path52 from "node:path";
 init_fs();
 init_paths();
 async function readLockSummary(root) {
@@ -10167,7 +10329,7 @@ async function backupLockfile(root) {
     await mkdir(backupDir, { recursive: true });
     let stamp = Date.now();
     for (; ; ) {
-      const dest = path51.join(backupDir, lockBackupFileName(stamp));
+      const dest = path52.join(backupDir, lockBackupFileName(stamp));
       try {
         await copyFile(lockPath, dest, fsConstants.COPYFILE_EXCL);
         return;
@@ -10218,7 +10380,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile2(path51.join(root, ".claude", "settings.json"), "utf8");
+    await readFile2(path52.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -10263,7 +10425,7 @@ async function runUpdate(options) {
     return;
   }
   if (options.check) {
-    const pkgJson2 = await readJson(path52.join(packageRoot(), "package.json"));
+    const pkgJson2 = await readJson(path53.join(packageRoot(), "package.json"));
     const currentVersion2 = pkgJson2?.version ?? "0.0.0";
     const [
       status,
@@ -10315,7 +10477,7 @@ async function runUpdate(options) {
     }
     return;
   }
-  const pkgJson = await readJson(path52.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path53.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -10386,7 +10548,7 @@ async function runFromHookCheck(root) {
   try {
     const summary = await readLockSummary(root);
     if (summary.count === 0) return;
-    const pkgJson = await readJson(path52.join(packageRoot(), "package.json"));
+    const pkgJson = await readJson(path53.join(packageRoot(), "package.json"));
     const currentVersion = pkgJson?.version ?? "0.0.0";
     const pin = readProjectCatalogPin(root);
     const honoursPin = pin.kind === "pinned" && summary.catalogRef === pin.ref;
@@ -10581,7 +10743,7 @@ init_exec();
 init_logger();
 import { existsSync as existsSync2 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import path53 from "node:path";
+import path54 from "node:path";
 var GIT_LOCATION_VARS = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -10641,11 +10803,11 @@ async function runClone(url, opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const target = path53.resolve(opts.dir?.trim() || repoNameFromUrl(url));
+  const target = path54.resolve(opts.dir?.trim() || repoNameFromUrl(url));
   if (existsSync2(target) && !await isEmptyDirectory(target)) {
     const check = await checkExistingTarget(target, url);
     if (check.kind === "matches") {
-      log(`\u2022 ${path53.basename(target)} already cloned here, matches ${url} \u2014 skipped`);
+      log(`\u2022 ${path54.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].`;
@@ -10694,8 +10856,8 @@ function isCatalogItemInstallable(item) {
 
 // src/install/scaffold.ts
 init_logger();
-import path54 from "node:path";
-import fs44 from "fs-extra";
+import path55 from "node:path";
+import fs45 from "fs-extra";
 async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   const scaffolded = [];
   const skipped = [];
@@ -10708,27 +10870,27 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
     skipped.push(name);
     if (outcome === "skipped-exists") skippedExisting.push(name);
   };
-  const realRoot = await fs44.realpath(catalogRoot).catch(() => null);
+  const realRoot = await fs45.realpath(catalogRoot).catch(() => null);
   for (const item of items) {
     if (item.type !== "config") continue;
-    const sourcePath = path54.resolve(catalogRoot, item.path);
-    const rel = path54.relative(catalogRoot, sourcePath);
-    const escapes = rel === "" || path54.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
+    const sourcePath = path55.resolve(catalogRoot, item.path);
+    const rel = path55.relative(catalogRoot, sourcePath);
+    const escapes = rel === "" || path55.isAbsolute(rel) || rel.split(/[/\\]/).some((seg) => seg === "..");
     if (escapes) {
       warn(`Skipping ${item.id}: path '${item.path}' escapes the catalog root`);
       continue;
     }
-    const realSource = await fs44.realpath(sourcePath).catch(() => null);
+    const realSource = await fs45.realpath(sourcePath).catch(() => null);
     if (!realRoot || !realSource) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
     }
-    const realRel = path54.relative(realRoot, realSource);
-    if (realRel !== "" && (path54.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
+    const realRel = path55.relative(realRoot, realSource);
+    if (realRel !== "" && (path55.isAbsolute(realRel) || realRel.split(/[/\\]/)[0] === "..")) {
       warn(`Skipping ${item.id}: path '${item.path}' resolves outside the catalog root`);
       continue;
     }
-    const stat = await fs44.lstat(sourcePath).catch(() => null);
+    const stat = await fs45.lstat(sourcePath).catch(() => null);
     if (!stat) {
       warn(`Skipping ${item.id}: source not found at ${sourcePath}`);
       continue;
@@ -10738,14 +10900,14 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
       continue;
     }
     if (stat.isFile()) {
-      const filename = path54.basename(sourcePath);
-      const dest = path54.join(projectRoot, filename);
+      const filename = path55.basename(sourcePath);
+      const dest = path55.join(projectRoot, filename);
       record(filename, await scaffoldFile(sourcePath, dest, item.id, projectRoot, opts));
     } else if (stat.isDirectory()) {
-      const entries = await fs44.readdir(sourcePath);
+      const entries = await fs45.readdir(sourcePath);
       for (const entry of entries) {
-        const src = path54.join(sourcePath, entry);
-        const dest = path54.join(projectRoot, entry);
+        const src = path55.join(sourcePath, entry);
+        const dest = path55.join(projectRoot, entry);
         record(entry, await scaffoldFile(src, dest, item.id, projectRoot, opts));
       }
     }
@@ -10753,42 +10915,42 @@ async function scaffoldConfigItems(projectRoot, catalogRoot, items, opts = {}) {
   return { scaffolded, skipped, skippedExisting };
 }
 async function scaffoldFile(src, dest, itemId, projectRoot, opts) {
-  const destDisplay = path54.relative(projectRoot, dest) || path54.basename(dest);
-  const srcStat = await fs44.lstat(src).catch(() => null);
+  const destDisplay = path55.relative(projectRoot, dest) || path55.basename(dest);
+  const srcStat = await fs45.lstat(src).catch(() => null);
   if (!srcStat) {
-    warn(`Skipping ${path54.basename(src)}: source not found`);
+    warn(`Skipping ${path55.basename(src)}: source not found`);
     return "skipped-refused";
   }
   if (srcStat.isSymbolicLink()) {
-    warn(`Skipping ${path54.basename(src)}: source is a symlink`);
+    warn(`Skipping ${path55.basename(src)}: source is a symlink`);
     return "skipped-refused";
   }
-  const exists = await fs44.pathExists(dest);
-  if (exists && !opts.force) {
+  const exists2 = await fs45.pathExists(dest);
+  if (exists2 && !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"} ${path54.basename(dest)} (${itemId})`);
+    log(`[dry-run] would ${exists2 ? "overwrite" : "create"} ${path55.basename(dest)} (${itemId})`);
     return "scaffolded";
   }
-  if (exists && opts.force) {
-    await fs44.remove(dest);
+  if (exists2 && opts.force) {
+    await fs45.remove(dest);
   }
-  await fs44.ensureDir(path54.dirname(dest));
-  await fs44.copy(src, dest, {
+  await fs45.ensureDir(path55.dirname(dest));
+  await fs45.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 !fs44.lstatSync(s).isSymbolicLink();
+        return !fs45.lstatSync(s).isSymbolicLink();
       } catch {
         return false;
       }
     }
   });
-  if (!opts.quiet) log(`${exists ? "Overwrote" : "Created"} ${path54.basename(dest)} (${itemId})`);
+  if (!opts.quiet) log(`${exists2 ? "Overwrote" : "Created"} ${path55.basename(dest)} (${itemId})`);
   return "scaffolded";
 }
 
@@ -10920,7 +11082,7 @@ async function runDecisionsGuard(options = {}) {
 }
 
 // src/commands/decisions.ts
-import path55 from "node:path";
+import path56 from "node:path";
 
 // src/decisions/next-number.ts
 async function nextDecisionNumber(root) {
@@ -11031,7 +11193,7 @@ async function runDecisions(sub, arg, options = {}) {
     return;
   }
   if (sub === "validate") {
-    const target = arg ? path55.resolve(root, arg) : void 0;
+    const target = arg ? path56.resolve(root, arg) : void 0;
     if (!target) {
       error("usage: haus decisions validate <path-to-decision.md>");
       process.exitCode = 1;
@@ -11500,27 +11662,27 @@ function guardBash(command) {
 }
 
 // src/security/guard-file-access.ts
-import fs45 from "node:fs";
-import path56 from "node:path";
+import fs46 from "node:fs";
+import path57 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 = fs45.realpathSync(candidate);
-    return resolved === path56.resolve(candidate) ? {} : { resolved };
+    const resolved = fs46.realpathSync(candidate);
+    return resolved === path57.resolve(candidate) ? {} : { resolved };
   } catch {
     try {
-      if (fs45.lstatSync(candidate).isSymbolicLink()) return { unverifiable: true };
+      if (fs46.lstatSync(candidate).isSymbolicLink()) return { unverifiable: true };
     } catch {
     }
-    const parent = path56.dirname(candidate);
+    const parent = path57.dirname(candidate);
     if (parent === candidate) return {};
     const viaParent = resolveOnDisk(parent);
     if (viaParent.unverifiable) return { unverifiable: true };
     if (viaParent.resolved)
-      return { resolved: path56.join(viaParent.resolved, path56.basename(candidate)) };
+      return { resolved: path57.join(viaParent.resolved, path57.basename(candidate)) };
     return {};
   }
 }
@@ -12070,7 +12232,7 @@ function buildOptInEligible(items, skipped) {
 }
 
 // src/commands/workspace/discover.ts
-import path57 from "node:path";
+import path58 from "node:path";
 import fg6 from "fast-glob";
 import YAML4 from "yaml";
 init_fs();
@@ -12113,10 +12275,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(path57.posix.dirname(match));
+    gitDirs.add(path58.posix.dirname(match));
   }
   for (const match of manifestMatches) {
-    manifestDirs.add(path57.posix.dirname(match));
+    manifestDirs.add(path58.posix.dirname(match));
   }
   const repoRoots = [...gitDirs];
   const manifestSorted = [...manifestDirs].sort(
@@ -12133,9 +12295,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 = 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);
+    const absDir = path58.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path58.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path58.basename(absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir);
@@ -12178,7 +12340,7 @@ function renderWorkspaceYaml(config) {
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path57.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path58.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -12611,11 +12773,11 @@ async function runInstall(options, deps = {}) {
 }
 
 // src/commands/new.ts
-import path59 from "node:path";
+import path60 from "node:path";
 
 // src/new-project/create-project.ts
-import path58 from "node:path";
-import fs46 from "fs-extra";
+import path59 from "node:path";
+import fs47 from "fs-extra";
 init_exec();
 init_logger();
 
@@ -12800,10 +12962,10 @@ var defaultDeps = {
 };
 var NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
 async function recordPackageManager(projectPath, pm, deps) {
-  const pkgPath = path58.join(projectPath, "package.json");
+  const pkgPath = path59.join(projectPath, "package.json");
   let pkg;
   try {
-    pkg = await fs46.readJson(pkgPath);
+    pkg = await fs47.readJson(pkgPath);
   } catch {
     return {};
   }
@@ -12818,7 +12980,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 fs46.writeJson(pkgPath, { ...pkg, packageManager: field }, { spaces: 2 });
+  await fs47.writeJson(pkgPath, { ...pkg, packageManager: field }, { spaces: 2 });
   return {};
 }
 var CONFIG_TOOLING = {
@@ -12831,12 +12993,12 @@ var CONFIG_TOOLING = {
   }
 };
 async function ensureConfigTooling(projectPath, scaffolded) {
-  const needed = scaffolded.map((file) => CONFIG_TOOLING[path58.basename(file)]).filter((entry) => entry !== void 0);
+  const needed = scaffolded.map((file) => CONFIG_TOOLING[path59.basename(file)]).filter((entry) => entry !== void 0);
   if (needed.length === 0) return [];
-  const pkgPath = path58.join(projectPath, "package.json");
+  const pkgPath = path59.join(projectPath, "package.json");
   let pkg;
   try {
-    pkg = await fs46.readJson(pkgPath);
+    pkg = await fs47.readJson(pkgPath);
   } catch {
     return [];
   }
@@ -12860,12 +13022,12 @@ async function ensureConfigTooling(projectPath, scaffolded) {
     }
   }
   if (!changed) return [];
-  await fs46.writeJson(pkgPath, { ...pkg, devDependencies, scripts }, { spaces: 2 });
+  await fs47.writeJson(pkgPath, { ...pkg, devDependencies, scripts }, { spaces: 2 });
   return added;
 }
 async function createProject(opts, deps = defaultDeps) {
   const steps = [];
-  const projectPath = path58.resolve(opts.parentDir, opts.name);
+  const projectPath = path59.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 });
@@ -12873,20 +13035,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 fs46.stat(path58.dirname(projectPath)).catch(() => null);
+  const parentStat = await fs47.stat(path59.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("\\") || path58.dirname(projectPath) !== path58.resolve(opts.parentDir)) {
+  if (!NAME_RE.test(opts.name) || opts.name.includes("/") || opts.name.includes("\\") || path59.dirname(projectPath) !== path59.resolve(opts.parentDir)) {
     return fail(
       "preflight",
       `Invalid project name "${opts.name}" (lowercase letters, digits, . _ - only).`
     );
   }
-  if (await fs46.pathExists(projectPath)) {
+  if (await fs47.pathExists(projectPath)) {
     return fail("preflight", `Target ${projectPath} already exists \u2014 refusing to write into it.`);
   }
   const scaffoldArgs = stack.scaffold.args.map(
@@ -12958,13 +13120,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 fs46.pathExists(projectPath) ? ` The directory was left for inspection \u2014 review it and remove it manually if unwanted (haus never auto-deletes).` : "";
+      const leftBehind = await fs47.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 fs46.pathExists(path58.join(projectPath, ".git"))) {
+    if (!await fs47.pathExists(path59.join(projectPath, ".git"))) {
       const init = await deps.git(["init"], { cwd: projectPath });
       if (init.exitCode !== 0) return fail("git", `git init failed: ${init.stderr}`);
     }
@@ -13190,7 +13352,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 : path59.resolve(cwd, flags.dir);
+  const parentDir = flags.dir === void 0 ? cwd : path60.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.` };
@@ -13288,7 +13450,7 @@ async function runRecommend(options) {
 }
 
 // src/commands/remove.ts
-import path60 from "node:path";
+import path61 from "node:path";
 init_fs();
 init_logger();
 init_paths();
@@ -13395,7 +13557,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 : path60.basename(backupRoot);
+  report.backupDir = backupRoot === null ? null : path61.basename(backupRoot);
   for (const { id, existing } of cleared) {
     await deleteTrackedPaths(root, id, existing, { verb: "Removed", reason: "" }, say);
   }
@@ -13485,8 +13647,8 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path61 from "node:path";
-import fs47 from "fs-extra";
+import path62 from "node:path";
+import fs48 from "fs-extra";
 
 // src/claude/managed-paths.ts
 init_paths();
@@ -13505,7 +13667,7 @@ init_paths();
 async function collectCoreManagedPaths(root) {
   const existing = [];
   for (const abs of coreManagedAbsolutePaths(root)) {
-    if (await fs47.pathExists(abs)) existing.push(abs);
+    if (await fs48.pathExists(abs)) existing.push(abs);
   }
   return existing;
 }
@@ -13519,7 +13681,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(path61.resolve(root, rel));
+      if (reason !== null) preserved.push(path62.resolve(root, rel));
     }
     if (existing.length === 0) continue;
     const gate = await hashGateEntry(root, { hash: row.hash }, existing);
@@ -13535,51 +13697,51 @@ async function collectLockTrackedPaths(root) {
 }
 async function settingsHasHausContent(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs47.pathExists(settingsPath)) return false;
+  if (!await fs48.pathExists(settingsPath)) return false;
   const settings = await readProjectSettings(root);
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path61.join(root, "CLAUDE.md");
-  if (!await fs47.pathExists(filePath)) return false;
-  const text = await fs47.readFile(filePath, "utf8");
+  const filePath = path62.join(root, "CLAUDE.md");
+  if (!await fs48.pathExists(filePath)) return false;
+  const text = await fs48.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
 }
 async function stripProjectSettings(root) {
   const settingsPath = claudePath(root, "settings.json");
-  if (!await fs47.pathExists(settingsPath)) return false;
+  if (!await fs48.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 ${path61.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path62.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
-  await fs47.remove(settingsPath);
-  log(`Removed ${path61.relative(root, settingsPath)} (no user-owned settings remained).`);
+  await fs48.remove(settingsPath);
+  log(`Removed ${path62.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path61.join(root, "CLAUDE.md");
-  if (!await fs47.pathExists(filePath)) return false;
-  const prev = await fs47.readFile(filePath, "utf8");
+  const filePath = path62.join(root, "CLAUDE.md");
+  if (!await fs48.pathExists(filePath)) return false;
+  const prev = await fs48.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
   const next = stripHausBlock(prev);
   if (next.length === 0) {
-    await fs47.remove(filePath);
+    await fs48.remove(filePath);
     log("Removed CLAUDE.md (only contained haus import block).");
   } else {
-    await fs47.writeFile(filePath, next, "utf8");
+    await fs48.writeFile(filePath, next, "utf8");
     log("Removed haus import block from CLAUDE.md (user content preserved).");
   }
   return true;
 }
 async function pruneDirIfEmpty(dir) {
-  if (!await fs47.pathExists(dir)) return;
+  if (!await fs48.pathExists(dir)) return;
   try {
-    const entries = await fs47.readdir(dir);
-    if (entries.length === 0) await fs47.remove(dir);
+    const entries = await fs48.readdir(dir);
+    if (entries.length === 0) await fs48.remove(dir);
   } catch {
   }
 }
@@ -13588,13 +13750,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 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);
+    if (!await fs48.pathExists(abs)) continue;
+    const rel = path62.relative(root, abs);
+    const backupPath = path62.join(backupRoot, rel);
+    await fs48.ensureDir(path62.dirname(backupPath));
+    await fs48.copy(abs, backupPath);
   }
-  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path61.relative(root, backupRoot)}.`);
+  log(`Backed up ${managedAbsPaths.length} managed file(s) to ${path62.relative(root, backupRoot)}.`);
 }
 async function runUndo(options) {
   const root = options.root ?? process.cwd();
@@ -13608,7 +13770,7 @@ async function runUndo(options) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path61.relative(root, p));
+  const relTargets = managed.map((p) => path62.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)");
@@ -13634,9 +13796,9 @@ User-owned .claude/ files will be preserved.`
   }
   await backupManagedFilesBeforeUndo(root, managed);
   for (const abs of coreManaged) {
-    if (!await fs47.pathExists(abs)) continue;
-    await fs47.remove(abs);
-    log(`Removed ${path61.relative(root, abs)}`);
+    if (!await fs48.pathExists(abs)) continue;
+    await fs48.remove(abs);
+    log(`Removed ${path62.relative(root, abs)}`);
   }
   for (const { id, existing } of lockRemovable) {
     await deleteTrackedPaths(root, id, existing, { verb: "Removed" }, log);
@@ -13653,8 +13815,8 @@ init_fs();
 init_logger();
 init_paths();
 import crypto4 from "node:crypto";
-import path62 from "node:path";
-import fs48 from "fs-extra";
+import path63 from "node:path";
+import fs49 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false, removePlugins = removeGlobalPlugins } = options;
   const manifest = await readManifest();
@@ -13691,8 +13853,8 @@ async function runUninstall(options = {}) {
     );
   }
   for (const entry of manifest.files) {
-    const exists = fs48.pathExistsSync(entry.destPath);
-    if (!exists) continue;
+    const exists2 = fs49.pathExistsSync(entry.destPath);
+    if (!exists2) continue;
     const content2 = await readText(entry.destPath);
     if (content2 === void 0) continue;
     const header = parseMarkdownHeader(content2);
@@ -13709,24 +13871,24 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs48.remove(entry.destPath);
-    await pruneEmptyDir(path62.dirname(entry.destPath));
+    await fs49.remove(entry.destPath);
+    await pruneEmptyDir(path63.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 = path62.join(globalClaudeDir(), "haus");
+  const hausDir = path63.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
-  if (fs48.pathExistsSync(manifestPath2)) {
-    await fs48.remove(manifestPath2);
+  if (fs49.pathExistsSync(manifestPath2)) {
+    await fs49.remove(manifestPath2);
   }
   await removeInstallConfig();
-  if (fs48.pathExistsSync(hausDir)) {
+  if (fs49.pathExistsSync(hausDir)) {
     try {
-      const remaining = await fs48.readdir(hausDir);
-      if (remaining.length === 0) await fs48.remove(hausDir);
+      const remaining = await fs49.readdir(hausDir);
+      if (remaining.length === 0) await fs49.remove(hausDir);
     } catch {
     }
   }
@@ -13795,15 +13957,15 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/validate-catalog.ts
-import path64 from "node:path";
+import path65 from "node:path";
 
 // src/catalog/validate-core.ts
 init_forbidden_content();
 init_manifest_item_fields();
 init_path_safety();
 init_validation_rules2();
-import fs49 from "node:fs";
-import path63 from "node:path";
+import fs50 from "node:fs";
+import path64 from "node:path";
 var ITEM_SEMVER_RE = /^\d+\.\d+\.\d+$/;
 var ITEM_ID_PATTERN = /^haus\./;
 function auditForbiddenStacks(items) {
@@ -13963,14 +14125,14 @@ function checkRequiredFrontmatter(text, label) {
 }
 function readForAudit(absPath, label, failures) {
   try {
-    return fs49.readFileSync(absPath, "utf8");
+    return fs50.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 = path63.relative(manifestDir, absPath);
+  const rel = path64.relative(manifestDir, absPath);
   const failures = [];
   const text = readForAudit(absPath, `${itemId}: ${rel}`, failures);
   if (text === null) return failures;
@@ -13992,55 +14154,55 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path || !isSafeCatalogPath(item.path)) continue;
-    const absPath = path63.join(manifestDir, item.path);
+    const absPath = path64.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path63.join(absPath, "SKILL.md");
-      if (!fs49.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path63.relative(manifestDir, skillMd)}`);
+      const skillMd = path64.join(absPath, "SKILL.md");
+      if (!fs50.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path64.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}: ${path63.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path64.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
-      if (!fs49.existsSync(absPath)) {
+      if (!fs50.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const rel = path63.relative(manifestDir, absPath);
+      const rel = path64.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 (!fs49.existsSync(absPath)) {
+      if (!fs50.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 (!fs49.existsSync(absPath)) {
+      if (!fs50.existsSync(absPath)) {
         failures.push(`${item.id}: missing command file ${item.path}`);
         continue;
       }
-      const rel = path63.relative(manifestDir, absPath);
+      const rel = path64.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 (!fs49.existsSync(absPath)) {
+      if (!fs50.existsSync(absPath)) {
         failures.push(`${item.id}: missing config path ${item.path}`);
       }
     } else if (item.type === "rule") {
-      if (!fs49.existsSync(absPath)) {
+      if (!fs50.existsSync(absPath)) {
         failures.push(`${item.id}: missing rule file ${item.path}`);
       }
     } else if (item.type === "asset") {
-      if (!fs49.existsSync(absPath)) {
+      if (!fs50.existsSync(absPath)) {
         failures.push(`${item.id}: missing asset file ${item.path}`);
       }
     }
@@ -14075,7 +14237,7 @@ function resolveItemType(relPath, pathTypeMap) {
 function walkAllFiles(dir, fn, failures) {
   let entries;
   try {
-    entries = fs49.readdirSync(dir, { withFileTypes: true });
+    entries = fs50.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -14084,7 +14246,7 @@ function walkAllFiles(dir, fn, failures) {
   }
   for (const entry of entries) {
     if (entry.name === ".DS_Store") continue;
-    const full = path63.join(dir, entry.name);
+    const full = path64.join(dir, entry.name);
     if (entry.isDirectory()) walkAllFiles(full, fn, failures);
     else fn(full);
   }
@@ -14108,12 +14270,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 = path63.join(manifestDir, dir);
-    if (!fs49.existsSync(abs)) continue;
+    const abs = path64.join(manifestDir, dir);
+    if (!fs50.existsSync(abs)) continue;
     walkAllFiles(
       abs,
       (file) => {
-        const relPath = path63.relative(manifestDir, file).replace(/\\/g, "/");
+        const relPath = path64.relative(manifestDir, file).replace(/\\/g, "/");
         if (!isPathClaimed(relPath, claimedPaths)) {
           failures.push(`orphaned on disk, claimed by no manifest item: ${relPath}`);
         }
@@ -14126,7 +14288,7 @@ function auditDiskOrphans(manifestDir, items) {
 function walkMd(dir, fn, failures) {
   let entries;
   try {
-    entries = fs49.readdirSync(dir, { withFileTypes: true });
+    entries = fs50.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     failures.push(
       `${dir}: unreadable subtree (${err instanceof Error ? err.message : String(err)})`
@@ -14134,7 +14296,7 @@ function walkMd(dir, fn, failures) {
     return;
   }
   for (const entry of entries) {
-    const full = path63.join(dir, entry.name);
+    const full = path64.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn, failures);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -14144,13 +14306,13 @@ function auditMarkdownContent(manifestDir, items) {
   const pathSourceMap = buildItemPathSourceMap(items);
   const pathTypeMap = buildItemPathTypeMap(items);
   for (const dir of ["skills", "agents", "templates", "commands", "sources"]) {
-    const abs = path63.join(manifestDir, dir);
-    if (!fs49.existsSync(abs)) continue;
+    const abs = path64.join(manifestDir, dir);
+    if (!fs50.existsSync(abs)) continue;
     const dirType = DIR_ITEM_TYPE[dir] ?? "";
     walkMd(
       abs,
       (file) => {
-        const rel = path63.relative(manifestDir, file);
+        const rel = path64.relative(manifestDir, file);
         const text = readForAudit(file, rel, failures);
         if (text === null) return;
         const norm = rel.replace(/\\/g, "/");
@@ -14198,8 +14360,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path64.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path64.dirname(abs);
+  const abs = path65.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path65.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -14220,8 +14382,8 @@ init_logger();
 
 // src/workspace/worktree/add.ts
 init_fs();
-import path71 from "node:path";
-import fs53 from "fs-extra";
+import path72 from "node:path";
+import fs54 from "fs-extra";
 
 // src/workspace/worktree/git-worktree.ts
 init_exec();
@@ -14243,8 +14405,8 @@ function isBranchCheckedOutElsewhereError(stderr) {
   return CHECKED_OUT_ELSEWHERE_PATTERNS.some((re) => re.test(stderr));
 }
 async function addWorktree(cwd, worktreePath2, branch, opts = {}) {
-  const exists = await branchExists(cwd, branch);
-  if (exists) {
+  const exists2 = await branchExists(cwd, branch);
+  if (exists2) {
     const result2 = await runGit(["worktree", "add", worktreePath2, branch], { cwd });
     return {
       ok: result2.exitCode === 0,
@@ -14341,13 +14503,13 @@ async function hasUnpushedWork(cwd) {
 }
 
 // src/workspace/worktree/hydrate.ts
-import path67 from "node:path";
-import fs51 from "fs-extra";
+import path68 from "node:path";
+import fs52 from "fs-extra";
 
 // src/workspace/worktree/cow-copy.ts
 init_exec();
-import path65 from "node:path";
-import fs50 from "fs-extra";
+import path66 from "node:path";
+import fs51 from "fs-extra";
 async function getMacFilesystemType(dir) {
   const df = await runCommand("df", ["-P", dir]);
   if (df.exitCode !== 0) return void 0;
@@ -14378,14 +14540,14 @@ async function detectCowStrategy(dir) {
   return "unknown-platform";
 }
 async function cowCopyDir(src, dest) {
-  const srcExists = await fs50.pathExists(src);
+  const srcExists = await fs51.pathExists(src);
   if (!srcExists)
     return { strategy: "unsupported", attempted: false, ok: false, error: "source missing" };
-  const strategy = await detectCowStrategy(path65.dirname(dest));
+  const strategy = await detectCowStrategy(path66.dirname(dest));
   if (strategy === "unsupported" || strategy === "unknown-platform") {
     return { strategy, attempted: false, ok: false };
   }
-  await fs50.ensureDir(path65.dirname(dest));
+  await fs51.ensureDir(path66.dirname(dest));
   const args = strategy === "darwin-clonefile" ? ["-c", "-R", src, dest] : ["-a", "--reflink=always", src, dest];
   const result = await runCommand("cp", args);
   return {
@@ -14399,7 +14561,7 @@ async function cowCopyDir(src, dest) {
 // src/workspace/worktree/install.ts
 init_exec();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 import fg7 from "fast-glob";
 function detectInstallPlan(signals) {
   if (signals.hasYarnLock) {
@@ -14420,10 +14582,10 @@ function detectInstallPlan(signals) {
   return { manager: "none" };
 }
 async function computeLockfileSignals(dir) {
-  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 hasYarnLock = existsSync3(path67.join(dir, "yarn.lock"));
+  const hasPnpmLock = existsSync3(path67.join(dir, "pnpm-lock.yaml"));
+  const hasPackageLock = existsSync3(path67.join(dir, "package-lock.json"));
+  const hasComposerLock = existsSync3(path67.join(dir, "composer.lock"));
   const dotnetFiles = await fg7(["**/*.csproj", "**/*.sln"], {
     cwd: dir,
     onlyFiles: true,
@@ -14437,7 +14599,7 @@ async function computeLockfileSignals(dir) {
   });
   const hasDotnetProject = dotnetFiles.length > 0;
   let hasPackageManagerField = false;
-  const pkgPath = path66.join(dir, "package.json");
+  const pkgPath = path67.join(dir, "package.json");
   if (existsSync3(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
@@ -14480,7 +14642,7 @@ function missingYarnrcEnvVars(content2, env) {
   return findRequiredYarnrcEnvVars(content2).filter((name) => env[name] === void 0);
 }
 function missingYarnrcEnvVarsInDir(dir, env) {
-  const yarnrcPath = path66.join(dir, ".yarnrc.yml");
+  const yarnrcPath = path67.join(dir, ".yarnrc.yml");
   if (!existsSync3(yarnrcPath)) return [];
   try {
     return missingYarnrcEnvVars(readFileSync3(yarnrcPath, "utf8"), env);
@@ -14576,13 +14738,13 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
   const start = Date.now();
   const targets = [];
   for (const target of HYDRATION_TARGETS) {
-    const src = path67.join(mainMemberPath, target);
-    const dest = path67.join(worktreeMemberPath, target);
-    if (!await fs51.pathExists(src)) continue;
-    const destExists = await fs51.pathExists(dest);
+    const src = path68.join(mainMemberPath, target);
+    const dest = path68.join(worktreeMemberPath, target);
+    if (!await fs52.pathExists(src)) continue;
+    const destExists = await fs52.pathExists(dest);
     if (!opts.force && destExists) continue;
     if (opts.force && destExists) {
-      await fs51.remove(dest);
+      await fs52.remove(dest);
     }
     const copy = await cowCopyDir(src, dest);
     targets.push({ target, copy });
@@ -14595,11 +14757,11 @@ async function hydrateMember(mainMemberPath, worktreeMemberPath, opts = {}) {
 
 // src/workspace/worktree/local-files.ts
 init_exec();
-import path68 from "node:path";
-import fs52 from "fs-extra";
+import path69 from "node:path";
+import fs53 from "fs-extra";
 var MACHINE_LOCAL_FILES = [
   "docker-compose.local.yml",
-  path68.join(".claude", "settings.local.json")
+  path69.join(".claude", "settings.local.json")
 ];
 async function isTracked(repoRoot, relFile) {
   const gitPath = relFile.replace(/\\/g, "/");
@@ -14609,12 +14771,12 @@ async function isTracked(repoRoot, relFile) {
 async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
   const copied = [];
   for (const rel of MACHINE_LOCAL_FILES) {
-    const src = path68.join(mainMemberPath, rel);
-    if (!await fs52.pathExists(src)) continue;
+    const src = path69.join(mainMemberPath, rel);
+    if (!await fs53.pathExists(src)) continue;
     if (await isTracked(mainMemberPath, rel)) continue;
-    const dest = path68.join(worktreeMemberPath, rel);
-    await fs52.ensureDir(path68.dirname(dest));
-    await fs52.copy(src, dest, { overwrite: true });
+    const dest = path69.join(worktreeMemberPath, rel);
+    await fs53.ensureDir(path69.dirname(dest));
+    await fs53.copy(src, dest, { overwrite: true });
     copied.push(rel);
   }
   return copied;
@@ -14622,15 +14784,15 @@ async function copyMachineLocalFiles(mainMemberPath, worktreeMemberPath) {
 
 // src/workspace/worktree/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path69 from "node:path";
+import path70 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(path69.join(workspaceRoot, WORKSPACE_FILE));
-  const hasManifest = existsSync4(path69.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const hasYaml = existsSync4(path70.join(workspaceRoot, WORKSPACE_FILE));
+  const hasManifest = existsSync4(path70.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!hasYaml && !hasManifest) {
     return {
       ok: false,
@@ -14656,10 +14818,10 @@ function selectMembers(members, only) {
 
 // src/workspace/worktree/state.ts
 init_fs();
-import path70 from "node:path";
+import path71 from "node:path";
 var WORKTREE_STATE_FILE = ".haus-worktree.json";
 function worktreesDir(mainRoot) {
-  return path70.join(mainRoot, ".claude", "worktrees");
+  return path71.join(mainRoot, ".claude", "worktrees");
 }
 function isValidWorktreeSlug(slug) {
   if (slug === "" || slug === "." || slug === "..") return false;
@@ -14672,22 +14834,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 path70.join(worktreesDir(mainRoot), slug);
+  return path71.join(worktreesDir(mainRoot), slug);
 }
 function slugFromWorktreePath(mainRoot, somePath) {
   const dir = worktreesDir(mainRoot);
-  const prefix = `${dir}${path70.sep}`;
+  const prefix = `${dir}${path71.sep}`;
   if (!somePath.startsWith(prefix)) return void 0;
-  const segment = somePath.slice(prefix.length).split(path70.sep)[0];
+  const segment = somePath.slice(prefix.length).split(path71.sep)[0];
   return segment !== void 0 && segment !== "" ? segment : void 0;
 }
 async function readWorktreeState(worktreeRoot) {
-  const state = await readJson(path70.join(worktreeRoot, WORKTREE_STATE_FILE));
+  const state = await readJson(path71.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(path70.join(worktreeRoot, WORKTREE_STATE_FILE), state);
+  await writeJson(path71.join(worktreeRoot, WORKTREE_STATE_FILE), state);
 }
 
 // src/workspace/worktree/add.ts
@@ -14702,7 +14864,7 @@ async function runAdd(opts) {
   }
   const branch = opts.branch ?? opts.slug;
   const wsWorktreePath = worktreePath(workspaceRoot, opts.slug);
-  if (await fs53.pathExists(wsWorktreePath)) {
+  if (await fs54.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.`
@@ -14721,7 +14883,7 @@ async function runAdd(opts) {
   const memberResults = [];
   for (const member of selected) {
     const start = Date.now();
-    const memberWorktreePath = path71.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path72.join(wsWorktreePath, member.folder);
     const outcome = await addWorktree(member.absPath, memberWorktreePath, branch, {
       preferDefaultBranchFrom: true
     });
@@ -14751,7 +14913,7 @@ async function runAdd(opts) {
   await mapWithConcurrency(okResults, async (result) => {
     const member = selected.find((m) => m.id === result.member);
     if (!member) return;
-    const memberWorktreePath = path71.join(wsWorktreePath, member.folder);
+    const memberWorktreePath = path72.join(wsWorktreePath, member.folder);
     const hydrationStart = Date.now();
     if (opts.hydrate !== false) {
       result.hydration = await hydrateMember(member.absPath, memberWorktreePath);
@@ -14788,9 +14950,9 @@ async function runDryRun(args) {
   const wsBranchExists = await branchExists(workspaceRoot, branch);
   const members = [];
   for (const member of selected) {
-    const exists = await branchExists(member.absPath, branch);
+    const exists2 = await branchExists(member.absPath, branch);
     let startPoint;
-    if (!exists) {
+    if (!exists2) {
       const def = await resolveDefaultBranch(member.absPath);
       startPoint = def?.ref;
     }
@@ -14799,7 +14961,7 @@ async function runDryRun(args) {
       folder: member.folder,
       status: "planned",
       branch,
-      branchAction: exists ? "checkout" : "create",
+      branchAction: exists2 ? "checkout" : "create",
       startPoint,
       durationMs: 0
     });
@@ -14819,17 +14981,17 @@ async function runDryRun(args) {
 // src/workspace/worktree/autohydrate.ts
 import { spawn } from "node:child_process";
 import fsSync from "node:fs";
-import path76 from "node:path";
-import fs55 from "fs-extra";
+import path77 from "node:path";
+import fs56 from "fs-extra";
 
 // src/workspace/worktree/doctor.ts
 import { existsSync as existsSync6 } from "node:fs";
-import path74 from "node:path";
+import path75 from "node:path";
 
 // src/workspace/worktree/hydrate-lock.ts
 init_paths();
-import path72 from "node:path";
-import fs54 from "fs-extra";
+import path73 from "node:path";
+import fs55 from "fs-extra";
 var STALE_LOCK_MS = 30 * 60 * 1e3;
 function locksDir(mainRoot) {
   return hausPath(mainRoot, "locks");
@@ -14846,13 +15008,13 @@ function assertSlug(slug) {
   return slug;
 }
 function hydrateLockPath(mainRoot, slug) {
-  return path72.join(locksDir(mainRoot), `hydrate-${assertSlug(slug)}.lock`);
+  return path73.join(locksDir(mainRoot), `hydrate-${assertSlug(slug)}.lock`);
 }
 function hydrateLogPath(mainRoot, slug) {
-  return path72.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.log`);
+  return path73.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.log`);
 }
 function hydrateLastRunPath(mainRoot, slug) {
-  return path72.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.last.json`);
+  return path73.join(logsDir(mainRoot), `hydrate-${assertSlug(slug)}.last.json`);
 }
 function defaultIsAlive(pid) {
   try {
@@ -14864,7 +15026,7 @@ function defaultIsAlive(pid) {
 }
 async function readOwnerPid(lockPath) {
   try {
-    const raw = (await fs54.readFile(path72.join(lockPath, "pid"), "utf8")).trim();
+    const raw = (await fs55.readFile(path73.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;
@@ -14873,13 +15035,13 @@ async function readOwnerPid(lockPath) {
   }
 }
 async function claim(lockPath, pid) {
-  await fs54.ensureDir(path72.dirname(lockPath));
+  await fs55.ensureDir(path73.dirname(lockPath));
   try {
-    await fs54.mkdir(lockPath);
+    await fs55.mkdir(lockPath);
   } catch {
     return false;
   }
-  await fs54.writeFile(path72.join(lockPath, "pid"), String(pid), "utf8");
+  await fs55.writeFile(path73.join(lockPath, "pid"), String(pid), "utf8");
   return true;
 }
 async function acquireHydrateLock(mainRoot, slug, deps = {}) {
@@ -14898,7 +15060,7 @@ async function acquireHydrateLock(mainRoot, slug, deps = {}) {
     }
     if (alive) return { acquired: false, reason: "live", ownerPid, lockPath };
   } else {
-    const stat = await fs54.stat(lockPath).catch(() => void 0);
+    const stat = await fs55.stat(lockPath).catch(() => void 0);
     if (stat === void 0) {
       return await claim(lockPath, pid) ? { acquired: true, lockPath } : { acquired: false, reason: "live", lockPath };
     }
@@ -14906,18 +15068,18 @@ async function acquireHydrateLock(mainRoot, slug, deps = {}) {
       return { acquired: false, reason: "starting", lockPath };
     }
   }
-  await fs54.remove(lockPath);
+  await fs55.remove(lockPath);
   return await claim(lockPath, pid) ? { acquired: true, lockPath } : { acquired: false, reason: "live", ownerPid, lockPath };
 }
 async function recordHydrateLockOwner(mainRoot, slug, pid) {
-  await fs54.writeFile(path72.join(hydrateLockPath(mainRoot, slug), "pid"), String(pid), "utf8");
+  await fs55.writeFile(path73.join(hydrateLockPath(mainRoot, slug), "pid"), String(pid), "utf8");
 }
 async function releaseHydrateLock(mainRoot, slug) {
-  await fs54.remove(hydrateLockPath(mainRoot, slug));
+  await fs55.remove(hydrateLockPath(mainRoot, slug));
 }
 async function readHydrateLock(mainRoot, slug) {
   const lockPath = hydrateLockPath(mainRoot, slug);
-  const stat = await fs54.stat(lockPath).catch(() => void 0);
+  const stat = await fs55.stat(lockPath).catch(() => void 0);
   if (stat === void 0) return { held: false };
   const ownerPid = await readOwnerPid(lockPath);
   return {
@@ -14930,21 +15092,21 @@ async function readHydrateLock(mainRoot, slug) {
 
 // src/workspace/worktree/orphans.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path73 from "node:path";
+import path74 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 = path73.normalize(entry.path);
-      const marker = `${path73.sep}.claude${path73.sep}worktrees${path73.sep}`;
+      const entryPath = path74.normalize(entry.path);
+      const marker = `${path74.sep}.claude${path74.sep}worktrees${path74.sep}`;
       const idx = entryPath.indexOf(marker);
       if (idx === -1) continue;
       const rest = entryPath.slice(idx + marker.length);
-      const slug = rest.split(path73.sep)[0];
+      const slug = rest.split(path74.sep)[0];
       if (!slug) continue;
-      if (existsSync5(path73.join(wsWorktreesDir, slug))) continue;
+      if (existsSync5(path74.join(wsWorktreesDir, slug))) continue;
       orphans.push({
         repoId: repo.id,
         ownerRepo: repo.absPath,
@@ -14959,7 +15121,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(path74.join(memberPath, marker)));
+  return HYDRATION_MARKERS.some((marker) => existsSync6(path75.join(memberPath, marker)));
 }
 async function runDoctor2() {
   const rootInfo = await resolveRoots();
@@ -14976,7 +15138,7 @@ async function runDoctor2() {
     };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const isWorkspace = existsSync6(path74.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path74.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const isWorkspace = existsSync6(path75.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path75.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!isWorkspace) {
     return {
       isWorkspace: false,
@@ -14992,7 +15154,7 @@ async function runDoctor2() {
     };
   }
   const wsWorktreesDir = worktreesDir(workspaceRoot);
-  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path74.sep}`);
+  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path75.sep}`);
   const inWorkspaceWorktree = rootInfo.isLinkedWorktree && underWorktreesDir;
   const workspaceConfig = await readWorkspaceConfig(workspaceRoot);
   const autoHydrate = workspaceConfig?.worktree?.autoHydrate === true;
@@ -15005,10 +15167,10 @@ async function runDoctor2() {
   let hydrationOwnerPid;
   if (inWorkspaceWorktree) {
     const wtPath = rootInfo.repoRoot;
-    slug = rootInfo.worktreeName ?? path74.basename(wtPath);
+    slug = rootInfo.worktreeName ?? path75.basename(wtPath);
     const state = await readWorktreeState(wtPath);
     for (const member of members) {
-      const memberPath = path74.join(wtPath, member.folder);
+      const memberPath = path75.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;
@@ -15053,7 +15215,7 @@ async function runDoctor2() {
     wsWorktreesDir
   );
   const orphans = orphanScan.map(
-    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path74.join(wsWorktreesDir, o.slug)} no longer exists.`
+    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path75.join(wsWorktreesDir, o.slug)} no longer exists.`
   );
   if (orphans.length > 0) {
     problems.push(...orphans);
@@ -15076,7 +15238,7 @@ async function runDoctor2() {
 // src/workspace/worktree/hydrate-command.ts
 init_fs();
 import { existsSync as existsSync7 } from "node:fs";
-import path75 from "node:path";
+import path76 from "node:path";
 async function runHydrateWorktree(opts) {
   const rootInfo = await resolveRoots();
   if (!rootInfo.isGitRepo || !rootInfo.isLinkedWorktree) {
@@ -15087,7 +15249,7 @@ async function runHydrateWorktree(opts) {
   }
   const workspaceRoot = rootInfo.mainRoot;
   const wtPath = rootInfo.repoRoot;
-  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path75.sep}`)) {
+  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path76.sep}`)) {
     return {
       ok: false,
       error: "Current worktree is not one of this workspace's .claude/worktrees/<slug> checkouts."
@@ -15099,13 +15261,13 @@ async function runHydrateWorktree(opts) {
     return { ok: false, error: `Unknown --only repo(s): ${unknown.join(", ")}` };
   }
   const state = await readWorktreeState(wtPath);
-  const slug = state?.slug ?? path75.basename(wtPath);
+  const slug = state?.slug ?? path76.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 = path75.join(wtPath, member.folder);
+        const memberPath = path76.join(wtPath, member.folder);
         if (existsSync7(memberPath)) {
           return { member: member.id, folder: member.folder, status: "planned" };
         }
@@ -15126,7 +15288,7 @@ async function runHydrateWorktree(opts) {
   const results = await mapWithConcurrency(
     selected,
     async (member) => {
-      const memberPath = path75.join(wtPath, member.folder);
+      const memberPath = path76.join(wtPath, member.folder);
       let branchAction;
       if (!existsSync7(memberPath)) {
         if (!opts.materialize) {
@@ -15247,7 +15409,7 @@ function defaultSpawnDetached(spec) {
 }
 function appendLog(logPath, line2) {
   try {
-    fsSync.mkdirSync(path76.dirname(logPath), { recursive: true });
+    fsSync.mkdirSync(path77.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) ---
@@ -15262,11 +15424,11 @@ async function consumeLastRunFailure(mainRoot, slug) {
   const file = hydrateLastRunPath(mainRoot, slug);
   let parsed;
   try {
-    parsed = JSON.parse(await fs55.readFile(file, "utf8"));
+    parsed = JSON.parse(await fs56.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
-  await fs55.remove(file).catch(() => void 0);
+  await fs56.remove(file).catch(() => void 0);
   if (parsed && parsed.ok === false) return parsed;
   return void 0;
 }
@@ -15338,7 +15500,7 @@ async function runAutoHydrate(opts = {}, deps = {}) {
       reason: "could not determine the haus CLI entry point to re-invoke"
     };
   }
-  await fs55.ensureDir(logsDir(mainRoot));
+  await fs56.ensureDir(logsDir(mainRoot));
   appendLog(
     logPath,
     `autohydrate: forking hydrate --materialize for "${slug}" (${missingMembers.join(", ")})`
@@ -15407,21 +15569,21 @@ async function runDetachedHydration() {
 async function writeLastRun(mainRoot, slug, ok, failures) {
   const file = hydrateLastRunPath(mainRoot, slug);
   if (ok) {
-    await fs55.remove(file).catch(() => void 0);
+    await fs56.remove(file).catch(() => void 0);
     return;
   }
   const record = { slug, finishedAt: (/* @__PURE__ */ new Date()).toISOString(), ok, failures };
-  await fs55.ensureDir(path76.dirname(file));
-  await fs55.writeJson(file, record, { spaces: 2 }).catch(() => void 0);
+  await fs56.ensureDir(path77.dirname(file));
+  await fs56.writeJson(file, record, { spaces: 2 }).catch(() => void 0);
 }
 
 // src/workspace/worktree/dematerialize.ts
-import path78 from "node:path";
-import fs57 from "fs-extra";
+import path79 from "node:path";
+import fs58 from "fs-extra";
 
 // src/workspace/worktree/member-targets.ts
-import path77 from "node:path";
-import fs56 from "fs-extra";
+import path78 from "node:path";
+import fs57 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 }));
 }
@@ -15438,7 +15600,7 @@ function resolveMemberTargets(wsWorktreePath, stateMembers, allMembers) {
     targets.push({
       repo: configMember?.id ?? stateMember.id,
       ownerRepo,
-      path: path77.join(wsWorktreePath, stateMember.folder)
+      path: path78.join(wsWorktreePath, stateMember.folder)
     });
   }
   return { targets, unresolvedDroppedMembers };
@@ -15446,7 +15608,7 @@ function resolveMemberTargets(wsWorktreePath, stateMembers, allMembers) {
 async function filterExistingTargets(targets) {
   const existing = [];
   for (const target of targets) {
-    if (await fs56.pathExists(target.path)) existing.push(target);
+    if (await fs57.pathExists(target.path)) existing.push(target);
   }
   return existing;
 }
@@ -15491,7 +15653,7 @@ async function runDematerialize(opts) {
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
-  if (!await fs57.pathExists(wsWorktreePath)) {
+  if (!await fs58.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const lock = await readHydrateLock(workspaceRoot, slug);
@@ -15524,9 +15686,9 @@ async function runDematerialize(opts) {
   const removed = [];
   const failed = [];
   for (const folder of unresolvedDroppedMembers) {
-    const droppedPath = path78.join(wsWorktreePath, folder);
-    if (await fs57.pathExists(droppedPath)) {
-      await fs57.remove(droppedPath);
+    const droppedPath = path79.join(wsWorktreePath, folder);
+    if (await fs58.pathExists(droppedPath)) {
+      await fs58.remove(droppedPath);
       failed.push({ repo: folder, error: unresolvedDroppedFailureReason() });
     }
   }
@@ -15540,26 +15702,26 @@ async function runDematerialize(opts) {
 }
 
 // src/workspace/worktree/list.ts
-import path79 from "node:path";
-import fs58 from "fs-extra";
+import path80 from "node:path";
+import fs59 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 fs58.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
-  const entries = await fs58.readdir(dir, { withFileTypes: true });
+  if (!await fs59.pathExists(dir)) return { ok: true, workspaceRoot, worktrees: [] };
+  const entries = await fs59.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 = path79.join(dir, slug);
+    const wtPath = path80.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 = path79.join(wtPath, m.folder);
-      const materialized = await fs58.pathExists(memberPath);
+      const memberPath = path80.join(wtPath, m.folder);
+      const materialized = await fs59.pathExists(memberPath);
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
       members.push({
         id: m.id,
@@ -15581,23 +15743,23 @@ async function runList2() {
 
 // src/workspace/worktree/reclaim.ts
 import { existsSync as existsSync8 } from "node:fs";
-import path80 from "node:path";
-import fs59 from "fs-extra";
+import path81 from "node:path";
+import fs60 from "fs-extra";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 async function lastTouchedMs(worktreeRoot) {
-  const candidates = [worktreeRoot, path80.join(worktreeRoot, ".haus-worktree.json")];
+  const candidates = [worktreeRoot, path81.join(worktreeRoot, ".haus-worktree.json")];
   try {
-    const dotGit = await fs59.readFile(path80.join(worktreeRoot, ".git"), "utf8");
+    const dotGit = await fs60.readFile(path81.join(worktreeRoot, ".git"), "utf8");
     const match = /^gitdir:\s*(.+)$/m.exec(dotGit);
     if (match?.[1]) {
       const gitdir = match[1].trim();
-      candidates.push(path80.join(gitdir, "HEAD"), path80.join(gitdir, "index"));
+      candidates.push(path81.join(gitdir, "HEAD"), path81.join(gitdir, "index"));
     }
   } catch {
   }
   let newest = 0;
   for (const candidate of candidates) {
-    const stat = await fs59.stat(candidate).catch(() => void 0);
+    const stat = await fs60.stat(candidate).catch(() => void 0);
     if (stat && stat.mtimeMs > newest) newest = stat.mtimeMs;
   }
   return newest;
@@ -15624,7 +15786,7 @@ async function runReclaim(opts = {}) {
   if (!existsSync8(dir)) {
     return { ok: true, dryRun: !opts.write, olderThanDays, candidates: [], reclaimed: 0 };
   }
-  const allEntries = (await fs59.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const allEntries = (await fs60.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);
@@ -15634,17 +15796,17 @@ async function runReclaim(opts = {}) {
   for (const name of unaddressable) {
     candidates.push({
       slug: name,
-      ageDays: (Date.now() - await lastTouchedMs(path80.join(dir, name))) / MS_PER_DAY,
+      ageDays: (Date.now() - await lastTouchedMs(path81.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 = path80.join(dir, slug);
+    const wtPath = path81.join(dir, slug);
     const state = await readWorktreeState(wtPath);
     const stateMembers = normalizeStateMembers(state, members);
-    const materialized = stateMembers.filter((m) => existsSync8(path80.join(wtPath, m.folder)));
+    const materialized = stateMembers.filter((m) => existsSync8(path81.join(wtPath, m.folder)));
     const ageDays = (Date.now() - await lastTouchedMs(wtPath)) / MS_PER_DAY;
     const base = { slug, ageDays, materializedMembers: materialized.length };
     if (slug === currentSlug) {
@@ -15705,13 +15867,13 @@ async function runReclaim(opts = {}) {
 }
 
 // src/workspace/worktree/remove.ts
-import fs60 from "fs-extra";
+import fs61 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 fs60.pathExists(wsWorktreePath)) {
+  if (!await fs61.pathExists(wsWorktreePath)) {
     return { ok: false, error: `No workspace worktree found at ${wsWorktreePath}.` };
   }
   const state = await readWorktreeState(wsWorktreePath);
@@ -15779,8 +15941,8 @@ async function runRemove2(opts) {
     }
     await pruneWorktrees(workspaceRoot);
   }
-  if (wsRemoveOk && await fs60.pathExists(wsWorktreePath)) {
-    await fs60.remove(wsWorktreePath);
+  if (wsRemoveOk && await fs61.pathExists(wsWorktreePath)) {
+    await fs61.remove(wsWorktreePath);
   }
   return { ok: failed.length === 0, dryRun: false, slug: opts.slug, removed, failed };
 }
@@ -16241,7 +16403,7 @@ async function runWorktree(action, opts = {}) {
 
 // src/commands/workspace.ts
 import { existsSync as existsSync12, statSync as statSync3 } from "node:fs";
-import path89 from "node:path";
+import path90 from "node:path";
 init_fs();
 init_logger();
 
@@ -16300,7 +16462,7 @@ ${summaries.map(
 
 // src/commands/workspace/doctor.ts
 import { existsSync as existsSync9 } from "node:fs";
-import path82 from "node:path";
+import path83 from "node:path";
 init_logger();
 init_paths();
 
@@ -16308,14 +16470,14 @@ init_paths();
 init_fs();
 init_paths();
 import { readFileSync as readFileSync4 } from "node:fs";
-import path81 from "node:path";
+import path82 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(path81.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path82.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -16407,7 +16569,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 = path82.resolve(workspaceRoot, repo.path);
+    const repoRoot = path83.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -16480,7 +16642,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         });
         continue;
       }
-      if (!existsSync9(path82.join(workspaceRoot, entry.path))) {
+      if (!existsSync9(path83.join(workspaceRoot, entry.path))) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-copy",
@@ -16526,18 +16688,18 @@ function emit(args) {
 init_logger();
 
 // src/workspace/link-context/link.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();
 
 // src/workspace/link-context/plan.ts
-import path84 from "node:path";
-import fs62 from "fs-extra";
+import path85 from "node:path";
+import fs63 from "fs-extra";
 
 // src/workspace/link-context/scan-source.ts
-import path83 from "node:path";
-import fs61 from "fs-extra";
+import path84 from "node:path";
+import fs62 from "fs-extra";
 var ASSET_SUBDIR = {
   skill: "skills",
   agent: "agents",
@@ -16545,36 +16707,36 @@ var ASSET_SUBDIR = {
 };
 async function hasLinkableContext(member) {
   for (const subdir of Object.values(ASSET_SUBDIR)) {
-    if (await fs61.pathExists(path83.join(member.absPath, ".claude", subdir))) return true;
+    if (await fs62.pathExists(path84.join(member.absPath, ".claude", subdir))) return true;
   }
   return false;
 }
 async function collectSkills(member) {
-  const dir = path83.join(member.absPath, ".claude", "skills");
-  if (!await fs61.pathExists(dir)) return [];
-  const names = await fs61.readdir(dir);
+  const dir = path84.join(member.absPath, ".claude", "skills");
+  if (!await fs62.pathExists(dir)) return [];
+  const names = await fs62.readdir(dir);
   const out = [];
   for (const name of [...names].sort()) {
-    const abs = path83.join(dir, name);
-    const stat = await fs61.lstat(abs);
+    const abs = path84.join(dir, name);
+    const stat = await fs62.lstat(abs);
     if (!stat.isDirectory()) continue;
-    if (!await fs61.pathExists(path83.join(abs, "SKILL.md"))) continue;
-    out.push({ type: "skill", name, sourceRelPath: path83.posix.join(".claude", "skills", name) });
+    if (!await fs62.pathExists(path84.join(abs, "SKILL.md"))) continue;
+    out.push({ type: "skill", name, sourceRelPath: path84.posix.join(".claude", "skills", name) });
   }
   return out;
 }
 async function collectFlatMarkdown(member, type) {
   const subdir = ASSET_SUBDIR[type];
-  const dir = path83.join(member.absPath, ".claude", subdir);
-  if (!await fs61.pathExists(dir)) return [];
-  const names = await fs61.readdir(dir);
+  const dir = path84.join(member.absPath, ".claude", subdir);
+  if (!await fs62.pathExists(dir)) return [];
+  const names = await fs62.readdir(dir);
   const out = [];
   for (const fileName of [...names].sort()) {
     if (!fileName.endsWith(".md")) continue;
-    const abs = path83.join(dir, fileName);
-    if (!(await fs61.lstat(abs)).isFile()) continue;
+    const abs = path84.join(dir, fileName);
+    if (!(await fs62.lstat(abs)).isFile()) continue;
     const name = fileName.slice(0, -".md".length);
-    out.push({ type, name, sourceRelPath: path83.posix.join(".claude", subdir, fileName) });
+    out.push({ type, name, sourceRelPath: path84.posix.join(".claude", subdir, fileName) });
   }
   return out;
 }
@@ -16589,9 +16751,9 @@ async function collectSourceAssets(member) {
 
 // src/workspace/link-context/plan.ts
 function repoFolderPrefix(member) {
-  const base = path84.posix.basename(member.folder);
+  const base = path85.posix.basename(member.folder);
   if (base && base !== "." && base !== "/") return base;
-  const fromAbs = path84.basename(member.absPath);
+  const fromAbs = path85.basename(member.absPath);
   return fromAbs || member.id;
 }
 function assetKey(type, destKey) {
@@ -16606,7 +16768,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 fs62.pathExists(member.absPath)) {
+    if (!await fs63.pathExists(member.absPath)) {
       skipped.push({ repo: member.id, reason: `not cloned locally (${member.absPath}) \u2014 skipped` });
       continue;
     }
@@ -16648,7 +16810,7 @@ async function buildLinkPlan(members) {
       name: asset.name,
       destKey,
       sourceRelPath: asset.sourceRelPath,
-      sourceAbsPath: path84.join(member.absPath, asset.sourceRelPath),
+      sourceAbsPath: path85.join(member.absPath, asset.sourceRelPath),
       sourceHash
     });
   }
@@ -16659,7 +16821,7 @@ async function buildLinkPlan(members) {
 function destRelPathFor(type, destKey) {
   const subdir = `${type}s`;
   const leaf = type === "skill" ? destKey : `${destKey}.md`;
-  return path85.posix.join(".claude", subdir, leaf);
+  return path86.posix.join(".claude", subdir, leaf);
 }
 async function runLinkContext(workspaceRoot, opts = {}) {
   const write = resolveWriteMode(opts, "preview-by-default").kind === "write";
@@ -16685,17 +16847,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 = path85.join(workspaceRoot, destRel);
+    const destAbs = path86.join(workspaceRoot, destRel);
     if (write) {
-      await fs63.ensureDir(path85.dirname(destAbs));
-      if (await fs63.pathExists(destAbs)) await fs63.remove(destAbs);
-      await fs63.copy(entry.sourceAbsPath, destAbs, {
+      await fs64.ensureDir(path86.dirname(destAbs));
+      if (await fs64.pathExists(destAbs)) await fs64.remove(destAbs);
+      await fs64.copy(entry.sourceAbsPath, destAbs, {
         overwrite: true,
         errorOnExist: false,
         dereference: false,
         filter: (s) => {
           try {
-            return !fs63.lstatSync(s).isSymbolicLink();
+            return !fs64.lstatSync(s).isSymbolicLink();
           } catch {
             return false;
           }
@@ -16724,7 +16886,7 @@ async function runLinkContext(workspaceRoot, opts = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${old.path}`);
         continue;
       }
-      if (await fs63.pathExists(abs)) await fs63.remove(abs);
+      if (await fs64.pathExists(abs)) await fs64.remove(abs);
     }
   }
   if (write) {
@@ -16776,11 +16938,11 @@ async function runWorkspaceLinkContext(workspaceRoot, opts = {}) {
 
 // src/commands/workspace/setup.ts
 import { existsSync as existsSync10, statSync } from "node:fs";
-import path87 from "node:path";
+import path88 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path86 from "node:path";
-import fs64 from "fs-extra";
+import path87 from "node:path";
+import fs65 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -16805,11 +16967,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") : path86.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path87.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
-  const existed = await fs64.pathExists(filePath);
-  const prev = existed ? await fs64.readFile(filePath, "utf8") : "";
+  const existed = await fs65.pathExists(filePath);
+  const prev = existed ? await fs65.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block, WORKSPACE_SENTINELS);
   const printable = displayPath(workspaceRoot, filePath);
@@ -16838,20 +17000,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 init_fs();
 init_logger();
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path87.resolve(start);
+  let dir = path88.resolve(start);
   for (; ; ) {
-    if (existsSync10(path87.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path87.dirname(dir);
-    if (parent === dir) return path87.resolve(start);
+    if (existsSync10(path88.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path88.dirname(dir);
+    if (parent === dir) return path88.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path87.resolve(workspaceRoot, repoPath) === path87.resolve(workspaceRoot);
+  return path88.resolve(workspaceRoot, repoPath) === path88.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path87.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path88.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -16878,7 +17040,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path87.resolve(workspaceRoot, repo.path);
+    const repoRoot = path88.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
     let res;
@@ -16994,7 +17156,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(path87.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path88.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -17050,7 +17212,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) => path87.join(workspaceRoot, rel)));
+        written.push(...linkResult.added.map((rel) => path88.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` : ""}.`
@@ -17083,8 +17245,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 path88 from "node:path";
-import fs65 from "fs-extra";
+import path89 from "node:path";
+import fs66 from "fs-extra";
 init_fs();
 init_logger();
 init_paths();
@@ -17114,7 +17276,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   if (options.dryRun) {
     for (const repo of config.repos) {
-      const repoRoot = path88.resolve(workspaceRoot, repo.path);
+      const repoRoot = path89.resolve(workspaceRoot, repo.path);
       log(`
 \u2192 ${repo.name} (${repo.path})`);
       try {
@@ -17135,7 +17297,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
         warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
         continue;
       }
-      if (await fs65.pathExists(abs)) {
+      if (await fs66.pathExists(abs)) {
         log(`[dry-run] Would remove ${entry.path} (linked ${entry.type} from ${entry.repo})`);
       }
     }
@@ -17145,12 +17307,12 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       hausPath(workspaceRoot, "WORKSPACE.md")
     ];
     for (const abs of workspaceArtifacts) {
-      if (await fs65.pathExists(abs)) {
-        log(`[dry-run] Would remove ${path88.relative(workspaceRoot, abs)}`);
+      if (await fs66.pathExists(abs)) {
+        log(`[dry-run] Would remove ${path89.relative(workspaceRoot, abs)}`);
       }
     }
-    if (!await fs65.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
-      const claudeMd = await readText(path88.join(workspaceRoot, "CLAUDE.md"));
+    if (!await fs66.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
+      const claudeMd = await readText(path89.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");
       }
@@ -17169,7 +17331,7 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   let anyRepoFailed = false;
   for (const repo of config.repos) {
-    const repoRoot = path88.resolve(workspaceRoot, repo.path);
+    const repoRoot = path89.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
@@ -17189,29 +17351,29 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
       warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
       continue;
     }
-    if (await fs65.pathExists(abs)) {
-      await fs65.remove(abs);
+    if (await fs66.pathExists(abs)) {
+      await fs66.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 fs65.pathExists(abs)) {
-      await fs65.remove(abs);
-      log(`Removed ${path88.relative(workspaceRoot, abs)}`);
+    if (await fs66.pathExists(abs)) {
+      await fs66.remove(abs);
+      log(`Removed ${path89.relative(workspaceRoot, abs)}`);
     }
   }
   const manifestFile = manifestPath(workspaceRoot);
-  if (await fs65.pathExists(manifestFile)) {
-    await fs65.remove(manifestFile);
-    log(`Removed ${path88.relative(workspaceRoot, manifestFile)}`);
+  if (await fs66.pathExists(manifestFile)) {
+    await fs66.remove(manifestFile);
+    log(`Removed ${path89.relative(workspaceRoot, manifestFile)}`);
   }
   const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
-  if (await fs65.pathExists(workspaceMdPath)) {
-    await fs65.remove(workspaceMdPath);
-    log(`Removed ${path88.relative(workspaceRoot, workspaceMdPath)}`);
+  if (await fs66.pathExists(workspaceMdPath)) {
+    await fs66.remove(workspaceMdPath);
+    log(`Removed ${path89.relative(workspaceRoot, workspaceMdPath)}`);
   } else {
-    const claudeMdPath = path88.join(workspaceRoot, "CLAUDE.md");
+    const claudeMdPath = path89.join(workspaceRoot, "CLAUDE.md");
     if (existsSync11(claudeMdPath)) {
       const prev = await readText(claudeMdPath);
       if (prev?.includes(WORKSPACE_BLOCK_BEGIN)) {
@@ -17220,19 +17382,19 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
           end: WORKSPACE_BLOCK_END
         });
         if (next.length === 0) {
-          await fs65.remove(claudeMdPath);
+          await fs66.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the workspace haus import block).");
         } else {
-          await fs65.writeFile(claudeMdPath, next, "utf8");
+          await fs66.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 fs65.remove(claudeMdPath);
+          await fs66.remove(claudeMdPath);
           log("Removed CLAUDE.md (only contained the pre-upgrade workspace haus import block).");
         } else {
-          await fs65.writeFile(claudeMdPath, next, "utf8");
+          await fs66.writeFile(claudeMdPath, next, "utf8");
           log(
             "Removed pre-upgrade workspace haus import block from CLAUDE.md (user content preserved)."
           );
@@ -17280,7 +17442,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path89.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path90.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -17302,7 +17464,7 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path89.resolve(workspaceRoot, repo.path);
+    const repoRoot = path90.resolve(workspaceRoot, repo.path);
     try {
       if (!existsSync12(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
@@ -17371,7 +17533,7 @@ init_logger();
 init_paths();
 function cliVersion() {
   try {
-    const pkgPath = path90.join(packageRoot(), "package.json");
+    const pkgPath = path91.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -17381,7 +17543,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path90.join(packageRoot(), "package.json");
+    const pkgPath = path91.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {