@haus-tech/haus-workflow 3.0.0 → 3.1.2

package/dist/cli.js

@@ -324,7 +324,8 @@ var init_path_safety = __esm({
 // src/utils/exec.ts
 var exec_exports = {};
 __export(exec_exports, {
-  commandExists: () => commandExists,
+  assertNeverCommandProbe: () => assertNeverCommandProbe,
+  probeCommand: () => probeCommand,
   runCommand: () => runCommand,
   runGit: () => runGit
 });
@@ -337,14 +338,17 @@ async function runCommand(command, args = [], options = {}) {
       ...options
     });
     const killed = result.timedOut === true || result.isCanceled === true || Boolean(result.signal);
+    const capturedStderr = String(result.stderr ?? "");
+    const timeoutReason = result.timedOut === true ? `timed out after ${options.timeout}ms` : void 0;
+    const stderr = timeoutReason === void 0 ? capturedStderr : capturedStderr.length > 0 ? `${capturedStderr}
+${timeoutReason}` : timeoutReason;
     return {
       command,
       args,
       stdout: String(result.stdout ?? ""),
-      stderr: String(
-        result.stderr ?? (result.timedOut === true ? `timed out after ${options.timeout}ms` : "")
-      ),
-      exitCode: result.exitCode ?? (killed || result.failed === true ? 1 : 0)
+      stderr,
+      exitCode: result.exitCode ?? (killed || result.failed === true ? 1 : 0),
+      killed
     };
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
@@ -354,14 +358,30 @@ async function runCommand(command, args = [], options = {}) {
 async function runGit(args, options = {}) {
   return runCommand("git", args, options);
 }
-async function commandExists(command, timeoutMs = 1e4) {
+function assertNeverCommandProbe(probe) {
+  throw new Error(`Unhandled CommandProbe: ${JSON.stringify(probe)}`);
+}
+async function probeOnce(command, timeoutMs, run) {
   try {
-    const result = await runCommand(command, ["--version"], { timeout: timeoutMs });
-    return result.exitCode === 0;
-  } catch {
-    return false;
+    const result = await run(command, ["--version"], { timeout: timeoutMs });
+    if (result.exitCode === 0) return { status: "available" };
+    if (result.killed) {
+      return {
+        status: "inconclusive",
+        reason: result.stderr.length > 0 ? result.stderr : `probe for "${command} --version" did not complete within ${timeoutMs}ms`
+      };
+    }
+    return { status: "absent" };
+  } catch (error2) {
+    const message2 = error2 instanceof Error ? error2.message : String(error2);
+    return { status: "inconclusive", reason: `probing "${command}" threw: ${message2}` };
   }
 }
+async function probeCommand(command, timeoutMs = 1e4, run = runCommand) {
+  const first = await probeOnce(command, timeoutMs, run);
+  if (first.status !== "inconclusive") return first;
+  return probeOnce(command, timeoutMs, run);
+}
 var init_exec = __esm({
   "src/utils/exec.ts"() {
     "use strict";
@@ -481,9 +501,9 @@ var init_github_rate_limit = __esm({
 // src/catalog/remote-catalog/http.ts
 import path4 from "node:path";
 import fs2 from "fs-extra";
-async function fetchGuarded(url, extract) {
+async function fetchGuarded(url, extract, headers = {}) {
   try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(1e4) });
     if (!res.ok) {
       warn(`Catalog fetch HTTP ${res.status}: ${url}`);
       return null;
@@ -494,11 +514,11 @@ async function fetchGuarded(url, extract) {
     return null;
   }
 }
-async function fetchText(url) {
-  return fetchGuarded(url, (res) => res.text());
+async function fetchText(url, headers = {}) {
+  return fetchGuarded(url, (res) => res.text(), headers);
 }
-async function fetchBytes(url) {
-  return fetchGuarded(url, async (res) => Buffer.from(await res.arrayBuffer()));
+async function fetchBytes(url, headers = {}) {
+  return fetchGuarded(url, async (res) => Buffer.from(await res.arrayBuffer()), headers);
 }
 async function writeTextIfChanged(dest, text) {
   if (await fs2.pathExists(dest)) {
@@ -728,6 +748,18 @@ async function resolveCatalogRef(opts) {
   );
   return "main";
 }
+async function catalogContentRequest(base, rel) {
+  if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
+    return { url: `${base}/${rel}`, headers: {} };
+  }
+  const ref = base.startsWith(`${CATALOG_REPO_URL}/`) ? base.slice(CATALOG_REPO_URL.length + 1) : getResolvedCatalogRef();
+  const headers = await getGithubApiHeaders();
+  headers["Accept"] = "application/vnd.github.raw";
+  return {
+    url: `${CATALOG_GITHUB_API_URL}/contents/${rel}?ref=${encodeURIComponent(ref)}`,
+    headers
+  };
+}
 async function remoteBase(projectRoot) {
   if (isTestMode() && process.env["HAUS_CATALOG_REMOTE_BASE"]) {
     return process.env["HAUS_CATALOG_REMOTE_BASE"];
@@ -1147,7 +1179,8 @@ var init_manifest_schema = __esm({
 // src/catalog/remote-catalog/manifest.ts
 async function fetchRemoteManifest(projectRoot) {
   const base = await remoteBase(projectRoot);
-  const text = await fetchText(`${base}/manifest.json`);
+  const { url, headers } = await catalogContentRequest(base, "manifest.json");
+  const text = await fetchText(url, headers);
   if (!text) return { ok: false, reason: "unavailable" };
   const parsed = parseManifest(text);
   if (!parsed.ok) {
@@ -1533,16 +1566,16 @@ function isMarkdownPath(rel) {
 async function fetchPrefixFiles(catalogPrefix, relFiles, base, label) {
   const fetched = [];
   for (const rel of relFiles) {
-    const url = `${base}/${catalogPrefix}/${rel}`;
+    const { url, headers } = await catalogContentRequest(base, `${catalogPrefix}/${rel}`);
     if (isMarkdownPath(rel)) {
-      const text = await fetchText(url);
+      const text = await fetchText(url, headers);
       if (text === null) {
         warn(`Failed to fetch ${rel} for ${label}`);
         return null;
       }
       fetched.push({ rel, kind: "text", body: text });
     } else {
-      const bytes = await fetchBytes(url);
+      const bytes = await fetchBytes(url, headers);
       if (bytes === null) {
         warn(`Failed to fetch ${rel} for ${label}`);
         return null;
@@ -1681,7 +1714,8 @@ async function syncConfigItem(item, base) {
       return "failed";
     }
   }
-  const text = await fetchText(`${base}/${item.path}`);
+  const configReq = await catalogContentRequest(base, item.path);
+  const text = await fetchText(configReq.url, configReq.headers);
   if (text === null) {
     warn(`Failed to fetch content for ${item.id}`);
     return "failed";
@@ -1739,7 +1773,8 @@ async function syncOneItem(item, base) {
     warn(`Skipping ${item.id}: path traversal detected`);
     return "failed";
   }
-  const text = await fetchText(`${base}/${item.path}`);
+  const itemReq = await catalogContentRequest(base, item.path);
+  const text = await fetchText(itemReq.url, itemReq.headers);
   if (text === null) {
     warn(`Failed to fetch content for ${item.id}`);
     return "failed";
@@ -1878,7 +1913,7 @@ var init_sync = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import path78 from "node:path";
+import path79 from "node:path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
@@ -1908,7 +1943,8 @@ var WORKFLOW_TEMPLATE_REL = "templates/agentic-workflow-standard.md";
 async function readWorkflowTemplate(opts = {}) {
   const dest = path7.join(getCacheDir(), WORKFLOW_TEMPLATE_REL);
   const base = await remoteBase(opts.projectRoot);
-  const text = await fetchText(`${base}/${WORKFLOW_TEMPLATE_REL}`);
+  const { url, headers } = await catalogContentRequest(base, WORKFLOW_TEMPLATE_REL);
+  const text = await fetchText(url, headers);
   if (text === null) {
     if (await fs6.pathExists(dest)) return fs6.readFile(dest, "utf8");
     return null;
@@ -3014,8 +3050,8 @@ function buildDenyRules() {
   for (const command of DENY_COMMANDS) {
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path79 of DENY_PATHS) {
-    const pattern = DENY_DIRS.has(path79) ? `${path79}/**` : path79;
+  for (const path80 of DENY_PATHS) {
+    const pattern = DENY_DIRS.has(path80) ? `${path80}/**` : path80;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -3228,9 +3264,20 @@ 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 ?? commandExists;
-  if (!await exists(command)) {
-    return { status: "skipped", reason: `${command} not found on PATH` };
+  const exists = deps.exists ?? probeCommand;
+  const probe = await exists(command);
+  switch (probe.status) {
+    case "available":
+      break;
+    case "absent":
+      return { status: "skipped", reason: `${command} not found on PATH` };
+    case "inconclusive":
+      return {
+        status: "skipped",
+        reason: `could not determine whether ${command} is on PATH (${probe.reason}) \u2014 dependency install skipped`
+      };
+    default:
+      return assertNeverCommandProbe(probe);
   }
   if (!await fs14.pathExists(contained.dir)) {
     return { status: "skipped", reason: `install directory disappeared (${contained.dir})` };
@@ -4962,8 +5009,24 @@ async function parseMarketplaces(stdout2, configDir) {
 }
 async function probePluginEnv(deps = {}) {
   const exec = deps.exec ?? realExec;
-  const isAvailable = deps.isAvailable ?? (() => commandExists("claude"));
   const warn2 = deps.warn ?? warn;
+  const probeClaude = deps.probeClaude ?? (() => probeCommand("claude"));
+  const isAvailable = deps.isAvailable ?? (async () => {
+    const probe = await probeClaude();
+    switch (probe.status) {
+      case "available":
+        return true;
+      case "absent":
+        return false;
+      case "inconclusive":
+        warn2(
+          `Could not determine whether the \`claude\` CLI is on PATH (${probe.reason}) \u2014 leaving global plugins untouched this run.`
+        );
+        return false;
+      default:
+        return assertNeverCommandProbe(probe);
+    }
+  });
   if (globalPluginsDisabled() && deps.exec === void 0) {
     return { available: false, installed: [], marketplaces: [] };
   }
@@ -6772,10 +6835,13 @@ function parseWorkspaceConfig(text) {
   const repos = Array.isArray(obj.repos) ? obj.repos.filter(
     (r) => typeof r === "object" && r !== null && typeof r.name === "string" && typeof r.path === "string"
   ) : [];
+  const worktreeRaw = parsed.worktree;
+  const worktree2 = typeof worktreeRaw === "object" && worktreeRaw !== null && !Array.isArray(worktreeRaw) ? { autoHydrate: worktreeRaw.autoHydrate === true } : void 0;
   return {
     client: typeof obj.client === "string" ? obj.client : "unknown",
     repos,
-    relationships: Array.isArray(obj.relationships) ? obj.relationships : []
+    relationships: Array.isArray(obj.relationships) ? obj.relationships : [],
+    ...worktree2 ? { worktree: worktree2 } : {}
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
@@ -10139,7 +10205,7 @@ function buildCompanionSuggestions(tools, isInstalled) {
   }
   return lines;
 }
-function commandExists2(bin) {
+function commandExists(bin) {
   try {
     const r = execaSync("sh", ["-c", 'command -v -- "$1"', "probe", bin], { reject: false });
     return r.exitCode === 0;
@@ -10148,7 +10214,7 @@ function commandExists2(bin) {
   }
 }
 function printCompanionToolSuggestions(deps = {}) {
-  const isInstalled = deps.isInstalled ?? commandExists2;
+  const isInstalled = deps.isInstalled ?? commandExists;
   const emit2 = deps.log ?? log;
   const lines = buildCompanionSuggestions(COMPANION_TOOLS, isInstalled);
   for (const line2 of lines) emit2(line2);
@@ -10239,7 +10305,7 @@ async function safeExec(exec, command, args, options) {
     return await exec(command, args, options);
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
-    return { command, args, stdout: "", stderr: message2, exitCode: 1 };
+    return { command, args, stdout: "", stderr: message2, exitCode: 1, killed: false };
   }
 }
 async function checkGh(exec = runCommand) {
@@ -10347,7 +10413,7 @@ var SCAFFOLD_TIMEOUT_MS = 3e5;
 var defaultDeps = {
   exec: runCommand,
   git: runGit,
-  commandExists,
+  commandExists: probeCommand,
   checkGh: () => checkGh(),
   checkOrg: (org) => checkOrg(org),
   createRepo,
@@ -10405,8 +10471,32 @@ async function createProject(opts, deps = defaultDeps) {
     });
     return { ok: true, projectPath, installHint, steps };
   }
-  if (!await deps.commandExists("npx") || !await deps.commandExists(opts.pm)) {
-    return fail("preflight", `Required tools missing: need npx and ${opts.pm} on PATH.`);
+  const requiredTools = ["npx", opts.pm];
+  const missingTools = [];
+  const inconclusiveTools = [];
+  for (const tool of requiredTools) {
+    const probe = await deps.commandExists(tool);
+    switch (probe.status) {
+      case "available":
+        break;
+      case "absent":
+        missingTools.push(tool);
+        break;
+      case "inconclusive":
+        inconclusiveTools.push(`${tool} (${probe.reason})`);
+        break;
+      default:
+        return assertNeverCommandProbe(probe);
+    }
+  }
+  if (missingTools.length > 0) {
+    return fail("preflight", `Required tools missing: need ${missingTools.join(" and ")} on PATH.`);
+  }
+  if (inconclusiveTools.length > 0) {
+    return fail(
+      "preflight",
+      `Could not confirm tool availability on PATH: ${inconclusiveTools.join("; ")} \u2014 the probe did not complete (likely transient load). Try again.`
+    );
   }
   if (opts.github) {
     const gh = await deps.checkGh();
@@ -11657,7 +11747,8 @@ async function removeWorktree(ownerRepo, worktreePath2, force = true) {
   return { ok: result.exitCode === 0, stderr: result.exitCode === 0 ? void 0 : result.stderr };
 }
 async function pruneWorktrees(ownerRepo) {
-  await runGit(["worktree", "prune"], { cwd: ownerRepo });
+  const result = await runGit(["worktree", "prune"], { cwd: ownerRepo });
+  return { ok: result.exitCode === 0, stderr: result.exitCode === 0 ? void 0 : result.stderr };
 }
 async function listWorktrees(ownerRepo) {
   const result = await runGit(["worktree", "list", "--porcelain"], { cwd: ownerRepo });
@@ -11835,13 +11926,26 @@ async function computeLockfileSignals(dir) {
     hasDotnetProject
   };
 }
-async function runInstallPlan(dir, plan) {
+async function runInstallPlan(dir, plan, deps = {}) {
   if (plan.manager === "none") {
     return { plan, ran: false, ok: true, skippedReason: "no recognized lockfile" };
   }
-  const available = await commandExists(plan.command);
-  if (!available) {
-    return { plan, ran: false, ok: true, skippedReason: `${plan.command} not found on PATH` };
+  const probe = deps.probe ?? probeCommand;
+  const probed = await probe(plan.command);
+  switch (probed.status) {
+    case "available":
+      break;
+    case "absent":
+      return { plan, ran: false, ok: true, skippedReason: `${plan.command} not found on PATH` };
+    case "inconclusive":
+      return {
+        plan,
+        ran: false,
+        ok: true,
+        skippedReason: `could not determine whether ${plan.command} is on PATH (${probed.reason})`
+      };
+    default:
+      return assertNeverCommandProbe(probed);
   }
   const result = await runCommand(plan.command, plan.args, { cwd: dir });
   return {
@@ -12093,11 +12197,41 @@ async function runDryRun(args) {
 }
 
 // src/workspace/worktree/doctor.ts
+import { existsSync as existsSync6 } from "node:fs";
+import path66 from "node:path";
+
+// src/workspace/worktree/orphans.ts
 import { existsSync as existsSync5 } from "node:fs";
 import path65 from "node:path";
+var WORKSPACE_REPO_ID = "(workspace)";
+async function findOrphanedRegistrations(repos, wsWorktreesDir) {
+  const orphans = [];
+  for (const repo of repos) {
+    const entries = await listWorktrees(repo.absPath);
+    for (const entry of entries) {
+      const entryPath = path65.normalize(entry.path);
+      const marker = `${path65.sep}.claude${path65.sep}worktrees${path65.sep}`;
+      const idx = entryPath.indexOf(marker);
+      if (idx === -1) continue;
+      const rest = entryPath.slice(idx + marker.length);
+      const slug = rest.split(path65.sep)[0];
+      if (!slug) continue;
+      if (existsSync5(path65.join(wsWorktreesDir, slug))) continue;
+      orphans.push({
+        repoId: repo.id,
+        ownerRepo: repo.absPath,
+        registeredPath: entry.path,
+        slug
+      });
+    }
+  }
+  return orphans;
+}
+
+// src/workspace/worktree/doctor.ts
 var HYDRATION_MARKERS = ["node_modules", "vendor", "obj", "bin"];
 function looksHydrated(memberPath) {
-  return HYDRATION_MARKERS.some((marker) => existsSync5(path65.join(memberPath, marker)));
+  return HYDRATION_MARKERS.some((marker) => existsSync6(path66.join(memberPath, marker)));
 }
 async function runDoctor2() {
   const rootInfo = await resolveRoots();
@@ -12107,11 +12241,13 @@ async function runDoctor2() {
       inWorkspaceWorktree: false,
       members: [],
       orphans: [],
-      problems: ["Not inside a git repository."]
+      problems: ["Not inside a git repository."],
+      remedies: [],
+      autoHydrate: false
     };
   }
   const workspaceRoot = rootInfo.mainRoot;
-  const isWorkspace = existsSync5(path65.join(workspaceRoot, WORKSPACE_FILE)) || existsSync5(path65.join(workspaceRoot, REPOS_MANIFEST_FILE));
+  const isWorkspace = existsSync6(path66.join(workspaceRoot, WORKSPACE_FILE)) || existsSync6(path66.join(workspaceRoot, REPOS_MANIFEST_FILE));
   if (!isWorkspace) {
     return {
       isWorkspace: false,
@@ -12120,23 +12256,28 @@ async function runDoctor2() {
       orphans: [],
       problems: [
         `Not a haus workspace \u2014 no ${WORKSPACE_FILE} or ${REPOS_MANIFEST_FILE} at ${workspaceRoot}.`
-      ]
+      ],
+      remedies: [],
+      autoHydrate: false
     };
   }
   const wsWorktreesDir = worktreesDir(workspaceRoot);
-  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path65.sep}`);
+  const underWorktreesDir = rootInfo.repoRoot.startsWith(`${wsWorktreesDir}${path66.sep}`);
   const inWorkspaceWorktree = rootInfo.isLinkedWorktree && underWorktreesDir;
+  const workspaceConfig = await readWorkspaceConfig(workspaceRoot);
+  const autoHydrate = workspaceConfig?.worktree?.autoHydrate === true;
   const members = await readMembers(rootInfo);
   const problems = [];
+  const remedies = [];
   const memberChecks = [];
   let slug;
   if (inWorkspaceWorktree) {
     const wtPath = rootInfo.repoRoot;
-    slug = rootInfo.worktreeName ?? path65.basename(wtPath);
+    slug = rootInfo.worktreeName ?? path66.basename(wtPath);
     const state = await readWorktreeState(wtPath);
     for (const member of members) {
-      const memberPath = path65.join(wtPath, member.folder);
-      const materialized = existsSync5(memberPath);
+      const memberPath = path66.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;
       const branchMismatch = Boolean(
@@ -12161,33 +12302,42 @@ async function runDoctor2() {
         );
       }
     }
-  }
-  const orphans = [];
-  for (const member of members) {
-    const entries = await listWorktrees(member.absPath);
-    for (const entry of entries) {
-      const entryPath = path65.normalize(entry.path);
-      const marker = `${path65.sep}.claude${path65.sep}worktrees${path65.sep}`;
-      const idx = entryPath.indexOf(marker);
-      if (idx === -1) continue;
-      const rest = entryPath.slice(idx + marker.length);
-      const slugName = rest.split(path65.sep)[0];
-      if (!slugName) continue;
-      if (!existsSync5(path65.join(wsWorktreesDir, slugName))) {
-        orphans.push(
-          `${member.id}: worktree registered at ${entry.path} but ${path65.join(wsWorktreesDir, slugName)} no longer exists \u2014 run \`git -C "${member.absPath}" worktree prune\`.`
-        );
-      }
+    if (memberChecks.some((m) => !m.materialized)) {
+      remedies.push(
+        "Run `haus workspace worktree hydrate --materialize` to materialize the missing members."
+      );
     }
   }
-  if (orphans.length > 0) problems.push(...orphans);
-  return { isWorkspace: true, inWorkspaceWorktree, slug, members: memberChecks, orphans, problems };
+  const orphanScan = await findOrphanedRegistrations(
+    [
+      { id: WORKSPACE_REPO_ID, absPath: workspaceRoot },
+      ...members.map((m) => ({ id: m.id, absPath: m.absPath }))
+    ],
+    wsWorktreesDir
+  );
+  const orphans = orphanScan.map(
+    (o) => `${o.repoId}: worktree registered at ${o.registeredPath} but ${path66.join(wsWorktreesDir, o.slug)} no longer exists.`
+  );
+  if (orphans.length > 0) {
+    problems.push(...orphans);
+    remedies.push("Run `haus workspace worktree prune` to clean up stale worktree registrations.");
+  }
+  return {
+    isWorkspace: true,
+    inWorkspaceWorktree,
+    slug,
+    members: memberChecks,
+    orphans,
+    problems,
+    remedies,
+    autoHydrate
+  };
 }
 
 // src/workspace/worktree/hydrate-command.ts
 init_fs();
-import { existsSync as existsSync6 } from "node:fs";
-import path66 from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import path67 from "node:path";
 async function runHydrateWorktree(opts) {
   const rootInfo = await resolveRoots();
   if (!rootInfo.isGitRepo || !rootInfo.isLinkedWorktree) {
@@ -12198,7 +12348,7 @@ async function runHydrateWorktree(opts) {
   }
   const workspaceRoot = rootInfo.mainRoot;
   const wtPath = rootInfo.repoRoot;
-  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path66.sep}`)) {
+  if (!wtPath.startsWith(`${worktreesDir(workspaceRoot)}${path67.sep}`)) {
     return {
       ok: false,
       error: "Current worktree is not one of this workspace's .claude/worktrees/<slug> checkouts."
@@ -12210,14 +12360,14 @@ async function runHydrateWorktree(opts) {
     return { ok: false, error: `Unknown --only repo(s): ${unknown.join(", ")}` };
   }
   const state = await readWorktreeState(wtPath);
-  const slug = state?.slug ?? path66.basename(wtPath);
+  const slug = state?.slug ?? path67.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 = path66.join(wtPath, member.folder);
-        if (existsSync6(memberPath)) {
+        const memberPath = path67.join(wtPath, member.folder);
+        if (existsSync7(memberPath)) {
           return { member: member.id, folder: member.folder, status: "planned" };
         }
         if (!opts.materialize) {
@@ -12225,7 +12375,7 @@ async function runHydrateWorktree(opts) {
             member: member.id,
             folder: member.folder,
             status: "skipped",
-            error: "not materialized in this worktree"
+            error: "not materialized in this worktree \u2014 re-run with --materialize to create it"
           };
         }
         const branchAction = await branchExists(member.absPath, targetBranch) ? "checkout" : "create";
@@ -12237,15 +12387,15 @@ async function runHydrateWorktree(opts) {
   const results = await mapWithConcurrency(
     selected,
     async (member) => {
-      const memberPath = path66.join(wtPath, member.folder);
+      const memberPath = path67.join(wtPath, member.folder);
       let branchAction;
-      if (!existsSync6(memberPath)) {
+      if (!existsSync7(memberPath)) {
         if (!opts.materialize) {
           return {
             member: member.id,
             folder: member.folder,
             status: "skipped",
-            error: "not materialized in this worktree"
+            error: "not materialized in this worktree \u2014 re-run with --materialize to create it"
           };
         }
         const outcome = await addWorktree(member.absPath, memberPath, targetBranch, {
@@ -12300,7 +12450,7 @@ async function runHydrateWorktree(opts) {
 }
 
 // src/workspace/worktree/list.ts
-import path67 from "node:path";
+import path68 from "node:path";
 import fs47 from "fs-extra";
 async function runList2() {
   const resolved = await resolveWorkspaceForWorktree();
@@ -12313,12 +12463,12 @@ async function runList2() {
   const configuredMembers = await readMembers(rootInfo);
   const worktrees = [];
   for (const slug of slugs) {
-    const wtPath = path67.join(dir, slug);
+    const wtPath = path68.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 = path67.join(wtPath, m.folder);
+      const memberPath = path68.join(wtPath, m.folder);
       const materialized = await fs47.pathExists(memberPath);
       const actualBranch = materialized ? await currentBranch(memberPath) : void 0;
       members.push({
@@ -12339,8 +12489,48 @@ async function runList2() {
   return { ok: true, workspaceRoot, worktrees };
 }
 
+// src/workspace/worktree/prune.ts
+async function runPrune2(opts) {
+  const resolved = await resolveWorkspaceForWorktree();
+  if (!resolved.ok) return { ok: false, error: resolved.reason };
+  const { rootInfo, workspaceRoot } = resolved;
+  const members = await readMembers(rootInfo);
+  const orphanScan = await findOrphanedRegistrations(
+    [
+      { id: WORKSPACE_REPO_ID, absPath: workspaceRoot },
+      ...members.map((m) => ({ id: m.id, absPath: m.absPath }))
+    ],
+    worktreesDir(workspaceRoot)
+  );
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const orphan of orphanScan) {
+    const bucket = byRepo.get(orphan.repoId) ?? { ownerRepo: orphan.ownerRepo, orphans: [] };
+    bucket.orphans.push(orphan);
+    byRepo.set(orphan.repoId, bucket);
+  }
+  if (opts.dryRun) {
+    const results2 = Array.from(byRepo, ([repo, { orphans }]) => ({
+      repo,
+      orphans: orphans.map((o) => o.registeredPath),
+      pruned: false
+    }));
+    return { ok: true, dryRun: true, results: results2 };
+  }
+  const results = [];
+  for (const [repo, { ownerRepo, orphans }] of byRepo) {
+    const outcome = await pruneWorktrees(ownerRepo);
+    results.push({
+      repo,
+      orphans: orphans.map((o) => o.registeredPath),
+      pruned: outcome.ok,
+      error: outcome.ok ? void 0 : outcome.stderr ?? "git worktree prune failed"
+    });
+  }
+  return { ok: results.every((r) => r.pruned), dryRun: false, results };
+}
+
 // src/workspace/worktree/remove.ts
-import path68 from "node:path";
+import path69 from "node:path";
 import fs48 from "fs-extra";
 async function runRemove2(opts) {
   const resolved = await resolveWorkspaceForWorktree();
@@ -12367,7 +12557,7 @@ async function runRemove2(opts) {
     targets.push({
       repo: configMember?.id ?? stateMember.id,
       ownerRepo,
-      path: path68.join(wsWorktreePath, stateMember.folder)
+      path: path69.join(wsWorktreePath, stateMember.folder)
     });
   }
   const existingTargets = [];
@@ -12580,6 +12770,32 @@ async function handleRemove(opts) {
     }
   }
 }
+async function handlePrune(opts) {
+  const result = await runPrune2({
+    dryRun: resolveWriteMode(opts, "mutate-by-default").kind === "preview"
+  });
+  if (!result.ok && "error" in result) {
+    if (opts.json) emitJson(result);
+    else error(result.error);
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.json) {
+    emitJson(result);
+    if (!result.dryRun && !result.ok) process.exitCode = 1;
+    return;
+  }
+  if (result.results.length === 0) {
+    log("No stale worktree registrations found.");
+    return;
+  }
+  for (const r of result.results) {
+    const prefix = result.dryRun ? "[dry-run] Would prune" : r.pruned ? "Pruned" : "FAILED to prune";
+    const detail = r.error ? ` \u2014 ${r.error}` : "";
+    log(`${prefix} ${r.repo}: ${r.orphans.join(", ")}${detail}`);
+  }
+  if (!result.dryRun && !result.ok) process.exitCode = 1;
+}
 async function handleList(opts) {
   const result = await runList2();
   if (opts.json) {
@@ -12631,12 +12847,17 @@ async function handleDoctor(opts) {
     }
     if (opts.fromHook) {
       const scope = report.slug ? `Workspace worktree "${report.slug}"` : "This haus workspace";
+      const needsMaterialize = report.members.some((m) => !m.materialized || !m.hydrated);
+      const directive = report.autoHydrate && needsMaterialize ? "autoHydrate is enabled for this workspace: run `haus workspace worktree hydrate --materialize` now, before any other work, to materialize and hydrate the missing members. " : "";
+      const remedies = directive ? report.remedies.filter((r) => !r.includes("--materialize")) : report.remedies;
+      const remedySuffix = remedies.length > 0 ? ` ${remedies.join(" ")}` : "";
       emitFromHookContext(
-        `${scope} has ${report.problems.length} issue(s): ${report.problems.join("; ")}`
+        `${directive}${scope} has ${report.problems.length} issue(s): ${report.problems.join("; ")}${remedySuffix}`
       );
       return;
     }
     for (const p of report.problems) warn(p);
+    for (const r of report.remedies) log(r);
     process.exitCode = 1;
   } catch (err) {
     const message2 = err instanceof Error ? err.message : String(err);
@@ -12660,12 +12881,14 @@ async function runWorktree(action, opts = {}) {
       return handleList(opts);
     case "doctor":
       return handleDoctor(opts);
+    case "prune":
+      return handlePrune(opts);
   }
 }
 
 // src/commands/workspace.ts
-import { existsSync as existsSync10, statSync as statSync3 } from "node:fs";
-import path77 from "node:path";
+import { existsSync as existsSync11, statSync as statSync3 } from "node:fs";
+import path78 from "node:path";
 init_fs();
 init_logger();
 
@@ -12723,8 +12946,8 @@ ${summaries.map(
 }
 
 // src/commands/workspace/doctor.ts
-import { existsSync as existsSync7 } from "node:fs";
-import path70 from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import path71 from "node:path";
 init_logger();
 init_paths();
 
@@ -12732,14 +12955,14 @@ init_paths();
 init_fs();
 init_paths();
 import { readFileSync as readFileSync4 } from "node:fs";
-import path69 from "node:path";
+import path70 from "node:path";
 var MANIFEST_FILE = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync4(path69.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(path70.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -12831,7 +13054,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 = path70.resolve(workspaceRoot, repo.path);
+    const repoRoot = path71.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -12856,7 +13079,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         detail: `Set up at haus ${entry.hausVersionAtSetup}, current is ${currentVersion} \u2014 re-run setup.`
       });
     }
-    if (!existsSync7(claudePath(repoRoot))) {
+    if (!existsSync8(claudePath(repoRoot))) {
       flag({
         repo: repo.name,
         kind: "missing-claude",
@@ -12865,7 +13088,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
     }
     const lock = await checkLock(repoRoot);
     if (lock.catalogRef) catalogRefByRepo.push({ repo: repo.name, ref: lock.catalogRef });
-    if (!existsSync7(hausPath(repoRoot, "haus.lock.json"))) {
+    if (!existsSync8(hausPath(repoRoot, "haus.lock.json"))) {
       flag({
         repo: repo.name,
         kind: "missing-lock",
@@ -12896,7 +13119,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
     const memberById = new Map(members.map((m) => [m.id, m]));
     for (const entry of manifest.linkedContext) {
       const member = memberById.get(entry.repo);
-      if (!member || !existsSync7(member.absPath)) {
+      if (!member || !existsSync8(member.absPath)) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-source",
@@ -12904,7 +13127,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         });
         continue;
       }
-      if (!existsSync7(path70.join(workspaceRoot, entry.path))) {
+      if (!existsSync8(path71.join(workspaceRoot, entry.path))) {
         flag({
           repo: entry.repo,
           kind: "missing-linked-context-copy",
@@ -12950,17 +13173,17 @@ function emit(args) {
 init_logger();
 
 // src/workspace/link-context/link.ts
-import path73 from "node:path";
+import path74 from "node:path";
 import fs51 from "fs-extra";
 init_fs();
 init_logger();
 
 // src/workspace/link-context/plan.ts
-import path72 from "node:path";
+import path73 from "node:path";
 import fs50 from "fs-extra";
 
 // src/workspace/link-context/scan-source.ts
-import path71 from "node:path";
+import path72 from "node:path";
 import fs49 from "fs-extra";
 var ASSET_SUBDIR = {
   skill: "skills",
@@ -12969,36 +13192,36 @@ var ASSET_SUBDIR = {
 };
 async function hasLinkableContext(member) {
   for (const subdir of Object.values(ASSET_SUBDIR)) {
-    if (await fs49.pathExists(path71.join(member.absPath, ".claude", subdir))) return true;
+    if (await fs49.pathExists(path72.join(member.absPath, ".claude", subdir))) return true;
   }
   return false;
 }
 async function collectSkills(member) {
-  const dir = path71.join(member.absPath, ".claude", "skills");
+  const dir = path72.join(member.absPath, ".claude", "skills");
   if (!await fs49.pathExists(dir)) return [];
   const names = await fs49.readdir(dir);
   const out = [];
   for (const name of [...names].sort()) {
-    const abs = path71.join(dir, name);
+    const abs = path72.join(dir, name);
     const stat = await fs49.lstat(abs);
     if (!stat.isDirectory()) continue;
-    if (!await fs49.pathExists(path71.join(abs, "SKILL.md"))) continue;
-    out.push({ type: "skill", name, sourceRelPath: path71.posix.join(".claude", "skills", name) });
+    if (!await fs49.pathExists(path72.join(abs, "SKILL.md"))) continue;
+    out.push({ type: "skill", name, sourceRelPath: path72.posix.join(".claude", "skills", name) });
   }
   return out;
 }
 async function collectFlatMarkdown(member, type) {
   const subdir = ASSET_SUBDIR[type];
-  const dir = path71.join(member.absPath, ".claude", subdir);
+  const dir = path72.join(member.absPath, ".claude", subdir);
   if (!await fs49.pathExists(dir)) return [];
   const names = await fs49.readdir(dir);
   const out = [];
   for (const fileName of [...names].sort()) {
     if (!fileName.endsWith(".md")) continue;
-    const abs = path71.join(dir, fileName);
+    const abs = path72.join(dir, fileName);
     if (!(await fs49.lstat(abs)).isFile()) continue;
     const name = fileName.slice(0, -".md".length);
-    out.push({ type, name, sourceRelPath: path71.posix.join(".claude", subdir, fileName) });
+    out.push({ type, name, sourceRelPath: path72.posix.join(".claude", subdir, fileName) });
   }
   return out;
 }
@@ -13013,9 +13236,9 @@ async function collectSourceAssets(member) {
 
 // src/workspace/link-context/plan.ts
 function repoFolderPrefix(member) {
-  const base = path72.posix.basename(member.folder);
+  const base = path73.posix.basename(member.folder);
   if (base && base !== "." && base !== "/") return base;
-  const fromAbs = path72.basename(member.absPath);
+  const fromAbs = path73.basename(member.absPath);
   return fromAbs || member.id;
 }
 function assetKey(type, destKey) {
@@ -13072,7 +13295,7 @@ async function buildLinkPlan(members) {
       name: asset.name,
       destKey,
       sourceRelPath: asset.sourceRelPath,
-      sourceAbsPath: path72.join(member.absPath, asset.sourceRelPath),
+      sourceAbsPath: path73.join(member.absPath, asset.sourceRelPath),
       sourceHash
     });
   }
@@ -13083,7 +13306,7 @@ async function buildLinkPlan(members) {
 function destRelPathFor(type, destKey) {
   const subdir = `${type}s`;
   const leaf = type === "skill" ? destKey : `${destKey}.md`;
-  return path73.posix.join(".claude", subdir, leaf);
+  return path74.posix.join(".claude", subdir, leaf);
 }
 async function runLinkContext(workspaceRoot, opts = {}) {
   const write = resolveWriteMode(opts, "preview-by-default").kind === "write";
@@ -13109,9 +13332,9 @@ 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 = path73.join(workspaceRoot, destRel);
+    const destAbs = path74.join(workspaceRoot, destRel);
     if (write) {
-      await fs51.ensureDir(path73.dirname(destAbs));
+      await fs51.ensureDir(path74.dirname(destAbs));
       if (await fs51.pathExists(destAbs)) await fs51.remove(destAbs);
       await fs51.copy(entry.sourceAbsPath, destAbs, {
         overwrite: true,
@@ -13199,11 +13422,11 @@ async function runWorkspaceLinkContext(workspaceRoot, opts = {}) {
 }
 
 // src/commands/workspace/setup.ts
-import { existsSync as existsSync8, statSync } from "node:fs";
-import path75 from "node:path";
+import { existsSync as existsSync9, statSync } from "node:fs";
+import path76 from "node:path";
 
 // src/claude/write-workspace-claude-md.ts
-import path74 from "node:path";
+import path75 from "node:path";
 import fs52 from "fs-extra";
 init_fs();
 init_logger();
@@ -13226,7 +13449,7 @@ ${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") : path74.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path75.join(workspaceRoot, "CLAUDE.md");
   const say = opts.quiet ? () => {
   } : log;
   const existed = await fs52.pathExists(filePath);
@@ -13259,20 +13482,20 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 init_fs();
 init_logger();
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path75.resolve(start);
+  let dir = path76.resolve(start);
   for (; ; ) {
-    if (existsSync8(path75.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path75.dirname(dir);
-    if (parent === dir) return path75.resolve(start);
+    if (existsSync9(path76.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path76.dirname(dir);
+    if (parent === dir) return path76.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path75.resolve(workspaceRoot, repoPath) === path75.resolve(workspaceRoot);
+  return path76.resolve(workspaceRoot, repoPath) === path76.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const apply = options.write ?? false;
-  const configText = await readText(path75.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path76.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -13299,11 +13522,11 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path75.resolve(workspaceRoot, repo.path);
+    const repoRoot = path76.resolve(workspaceRoot, repo.path);
     say(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
-      if (!existsSync8(repoRoot) || !statSync(repoRoot).isDirectory()) {
+      if (!existsSync9(repoRoot) || !statSync(repoRoot).isDirectory()) {
         throw new Error(`Repo path is not a directory: ${repo.path}`);
       }
       const res = await runSetupCore(repoRoot, {
@@ -13378,7 +13601,7 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   if (apply && !options.dryRun) {
     const statusByName = new Map(statuses.map((s) => [s.name, s]));
     const prior = await readManifest2(workspaceRoot);
-    if (!prior && existsSync8(manifestPath(workspaceRoot))) {
+    if (!prior && existsSync9(manifestPath(workspaceRoot))) {
       warn(
         "Existing workspace.manifest.json is unreadable \u2014 prior per-repo state will not be carried forward."
       );
@@ -13389,7 +13612,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(path75.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path76.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -13445,7 +13668,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) => path75.join(workspaceRoot, rel)));
+        written.push(...linkResult.added.map((rel) => path76.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` : ""}.`
@@ -13476,8 +13699,8 @@ Workspace setup complete: ${ok} ok, ${failed} failed. Wrote ${written.length} fi
 }
 
 // src/commands/workspace/undo.ts
-import { existsSync as existsSync9, statSync as statSync2 } from "node:fs";
-import path76 from "node:path";
+import { existsSync as existsSync10, statSync as statSync2 } from "node:fs";
+import path77 from "node:path";
 import fs53 from "fs-extra";
 init_fs();
 init_logger();
@@ -13508,11 +13731,11 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   if (options.dryRun) {
     for (const repo of config.repos) {
-      const repoRoot = path76.resolve(workspaceRoot, repo.path);
+      const repoRoot = path77.resolve(workspaceRoot, repo.path);
       log(`
 \u2192 ${repo.name} (${repo.path})`);
       try {
-        if (!existsSync9(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+        if (!existsSync10(repoRoot) || !statSync2(repoRoot).isDirectory()) {
           throw new Error(`Repo path is not a directory: ${repo.path}`);
         }
         await runUndo({ dryRun: true, root: repoRoot });
@@ -13540,11 +13763,11 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
     ];
     for (const abs of workspaceArtifacts) {
       if (await fs53.pathExists(abs)) {
-        log(`[dry-run] Would remove ${path76.relative(workspaceRoot, abs)}`);
+        log(`[dry-run] Would remove ${path77.relative(workspaceRoot, abs)}`);
       }
     }
     if (!await fs53.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
-      const claudeMd = await readText(path76.join(workspaceRoot, "CLAUDE.md"));
+      const claudeMd = await readText(path77.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");
       }
@@ -13563,11 +13786,11 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   }
   let anyRepoFailed = false;
   for (const repo of config.repos) {
-    const repoRoot = path76.resolve(workspaceRoot, repo.path);
+    const repoRoot = path77.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
-      if (!existsSync9(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+      if (!existsSync10(repoRoot) || !statSync2(repoRoot).isDirectory()) {
         throw new Error(`Repo path is not a directory: ${repo.path}`);
       }
       await runUndo({ yes: true, root: repoRoot });
@@ -13592,21 +13815,21 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
     const abs = hausPath(workspaceRoot, rel);
     if (await fs53.pathExists(abs)) {
       await fs53.remove(abs);
-      log(`Removed ${path76.relative(workspaceRoot, abs)}`);
+      log(`Removed ${path77.relative(workspaceRoot, abs)}`);
     }
   }
   const manifestFile = manifestPath(workspaceRoot);
   if (await fs53.pathExists(manifestFile)) {
     await fs53.remove(manifestFile);
-    log(`Removed ${path76.relative(workspaceRoot, manifestFile)}`);
+    log(`Removed ${path77.relative(workspaceRoot, manifestFile)}`);
   }
   const workspaceMdPath = hausPath(workspaceRoot, "WORKSPACE.md");
   if (await fs53.pathExists(workspaceMdPath)) {
     await fs53.remove(workspaceMdPath);
-    log(`Removed ${path76.relative(workspaceRoot, workspaceMdPath)}`);
+    log(`Removed ${path77.relative(workspaceRoot, workspaceMdPath)}`);
   } else {
-    const claudeMdPath = path76.join(workspaceRoot, "CLAUDE.md");
-    if (existsSync9(claudeMdPath)) {
+    const claudeMdPath = path77.join(workspaceRoot, "CLAUDE.md");
+    if (existsSync10(claudeMdPath)) {
       const prev = await readText(claudeMdPath);
       if (prev?.includes(WORKSPACE_BLOCK_BEGIN)) {
         const next = stripHausBlock(prev, {
@@ -13652,7 +13875,7 @@ function normalizeMaxDepth(maxDepth) {
   return void 0;
 }
 async function initWorkspace(options = {}) {
-  if (existsSync10(WORKSPACE_FILE) && !options.yes) {
+  if (existsSync11(WORKSPACE_FILE) && !options.yes) {
     const ok = await confirm(
       `${WORKSPACE_FILE} already exists \u2014 overwrite with a fresh placeholder? Existing client/repos/relationships will be lost. Run \`haus workspace discover\` instead to merge in newly found repos.`
     );
@@ -13674,7 +13897,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path77.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path78.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -13696,9 +13919,9 @@ async function scanWorkspace(workspaceRoot, opts) {
   const inputs = [];
   const failures = [];
   for (const repo of config.repos) {
-    const repoRoot = path77.resolve(workspaceRoot, repo.path);
+    const repoRoot = path78.resolve(workspaceRoot, repo.path);
     try {
-      if (!existsSync10(repoRoot) || !statSync3(repoRoot).isDirectory()) {
+      if (!existsSync11(repoRoot) || !statSync3(repoRoot).isDirectory()) {
         throw new Error("path is not a directory");
       }
       const result = await scanProject(repoRoot);
@@ -13764,7 +13987,7 @@ init_logger();
 init_paths();
 function cliVersion() {
   try {
-    const pkgPath = path78.join(packageRoot(), "package.json");
+    const pkgPath = path79.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -13774,7 +13997,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path78.join(packageRoot(), "package.json");
+    const pkgPath = path79.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -13911,6 +14134,11 @@ worktree.command("list").description("List materialized workspace worktrees and
 worktree.command("remove <slug>").description("Remove a workspace worktree and its member worktrees").option("--force", "Bypass the uncommitted/unpushed-work refusal").option("--dry-run", "Preview without removing anything").option("--json", "Emit the structured remove result as JSON").action(
   (slug, opts) => runWorktree("remove", { slug, force: opts.force, dryRun: opts.dryRun, json: opts.json })
 );
+worktree.command("prune").description(
+  "Remove stale worktree registrations left by a workspace worktree deleted without `haus workspace worktree remove` (e.g. a natively deleted Claude Code worktree)"
+).option("--dry-run", "Preview which registrations would be pruned").option("--json", "Emit the structured prune result as JSON").action(
+  (opts) => runWorktree("prune", { dryRun: opts.dryRun, json: opts.json })
+);
 worktree.command("doctor").description("Fast, side-effect-free health check for the current workspace worktree").option("--from-hook", "Emit for the SessionStart hook \u2014 always exits 0").action((opts) => runWorktree("doctor", { fromHook: opts.fromHook }));
 program.parseAsync(process.argv).catch((err) => {
   const message2 = err instanceof Error ? err.message : String(err);