@haus-tech/haus-workflow 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [1.7.0](https://github.com/WeAreHausTech/haus-workflow/compare/v1.6.0...v1.7.0) (2026-08-13)
+
+### Features
+
+- **cli:** --dry-run on destructive commands; doctor states what --force discards ([#283](https://github.com/WeAreHausTech/haus-workflow/issues/283)) ([35dfe55](https://github.com/WeAreHausTech/haus-workflow/commit/35dfe553e8282011d365492a3168fee7aee819b4)), closes [#237](https://github.com/WeAreHausTech/haus-workflow/issues/237) [#248](https://github.com/WeAreHausTech/haus-workflow/issues/248)
+- **cli:** add --json to workspace worktree and backups subcommands ([#280](https://github.com/WeAreHausTech/haus-workflow/issues/280)) ([bf1f7b2](https://github.com/WeAreHausTech/haus-workflow/commit/bf1f7b219432ee7cf2dfe6a70e8ae74ab8963b46)), closes [#235](https://github.com/WeAreHausTech/haus-workflow/issues/235) [#236](https://github.com/WeAreHausTech/haus-workflow/issues/236)
+- **cli:** doctor --json and explain-recommendation hint in recommend output ([#281](https://github.com/WeAreHausTech/haus-workflow/issues/281)) ([12fa8ff](https://github.com/WeAreHausTech/haus-workflow/commit/12fa8ff3723a07b735529cfdb32e193302a90bc2)), closes [#234](https://github.com/WeAreHausTech/haus-workflow/issues/234) [#234](https://github.com/WeAreHausTech/haus-workflow/issues/234) [#247](https://github.com/WeAreHausTech/haus-workflow/issues/247)
+- **cli:** upgrade visibility — release notes on update, lingering deprecated-item detection in doctor ([#284](https://github.com/WeAreHausTech/haus-workflow/issues/284)) ([e8d0c04](https://github.com/WeAreHausTech/haus-workflow/commit/e8d0c04b2e7d457cc0e4ea20f18a55fd4d8ee394)), closes [#242](https://github.com/WeAreHausTech/haus-workflow/issues/242) [#251](https://github.com/WeAreHausTech/haus-workflow/issues/251)
+
 ## [1.6.0](https://github.com/WeAreHausTech/haus-workflow/compare/v1.5.8...v1.6.0) (2026-08-13)
 
 ### Features

package/dist/cli.js

@@ -4644,14 +4644,24 @@ function formatAge(mtimeMs, now) {
   if (hours < 48) return `${hours}h ago`;
   return `${Math.round(hours / 24)}d ago`;
 }
-async function runList(root) {
+async function runList(root, json) {
   const entries = await listBackups(root);
+  const newestFirst = [...entries].reverse();
+  if (json) {
+    log(
+      JSON.stringify(
+        newestFirst.map(({ id, kind, mtimeMs, absPath }) => ({ id, kind, mtimeMs, absPath })),
+        null,
+        2
+      )
+    );
+    return;
+  }
   if (entries.length === 0) {
     log("No backups found under .haus-workflow/backups/.");
     return;
   }
   const now = Date.now();
-  const newestFirst = [...entries].reverse();
   for (const entry of newestFirst) {
     log(`${entry.id}  [${entry.kind}]  ${formatAge(entry.mtimeMs, now)}`);
   }
@@ -4685,13 +4695,13 @@ async function lstatIfRegularFile(abs) {
     throw err;
   }
 }
-async function restoreLockBackup(root, entry, yes) {
+async function restoreLockBackup(root, entry, yes, json, dryRun) {
   const target = hausPath(root, "haus.lock.json");
   if (await isUnsafeWriteTarget(root, target)) {
     error(
       `Refusing to restore: ${target} (or a parent directory) is a symlink or other non-regular file \u2014 never written through.`
     );
-    return false;
+    return { ok: false, restored: 0 };
   }
   if (await fs22.pathExists(target)) {
     const targetStat = await fs22.stat(target);
@@ -4701,22 +4711,30 @@ async function restoreLockBackup(root, entry, yes) {
       );
     }
   }
+  if (dryRun) {
+    if (!json) {
+      log(
+        `[dry-run] Would restore .haus-workflow/haus.lock.json from ${entry.id}. Nothing was changed.`
+      );
+    }
+    return { ok: true, restored: 0, dryRun: true, wouldRestore: [".haus-workflow/haus.lock.json"] };
+  }
   if (!yes) {
     const ok = await confirm(
       `Restore .haus-workflow/haus.lock.json from backup ${entry.id}? This overwrites the current lockfile.`
     );
     if (!ok) {
-      log("Cancelled.");
-      return false;
+      if (!json) log("Cancelled.");
+      return { ok: false, restored: 0 };
     }
   }
   if (!await lstatIfRegularFile(entry.absPath) || await isUnsafeWriteTarget(root, target)) {
     error(`Refusing to restore: ${entry.id} or ${target} changed since being checked.`);
-    return false;
+    return { ok: false, restored: 0 };
   }
   await fs22.copy(entry.absPath, target, { overwrite: true });
-  log(`Restored .haus-workflow/haus.lock.json from ${entry.id}.`);
-  return true;
+  if (!json) log(`Restored .haus-workflow/haus.lock.json from ${entry.id}.`);
+  return { ok: true, restored: 1 };
 }
 async function collectFilesRecursive(dir) {
   const files = [];
@@ -4743,7 +4761,7 @@ async function collectFilesRecursive(dir) {
   }
   return { files, skippedLinks, skippedOther };
 }
-async function restoreDirBackup(root, entry, yes) {
+async function restoreDirBackup(root, entry, yes, json, dryRun) {
   const { files, skippedLinks, skippedOther } = await collectFilesRecursive(entry.absPath);
   if (skippedLinks.length > 0) {
     warn(
@@ -4756,8 +4774,8 @@ async function restoreDirBackup(root, entry, yes) {
     );
   }
   if (files.length === 0) {
-    log(`Backup ${entry.id} contains no files.`);
-    return false;
+    if (!json) log(`Backup ${entry.id} contains no files.`);
+    return { ok: false, restored: 0 };
   }
   const safeFiles = [];
   const unsafeTargets = [];
@@ -4773,8 +4791,8 @@ async function restoreDirBackup(root, entry, yes) {
     );
   }
   if (safeFiles.length === 0) {
-    log(`Backup ${entry.id} has no restorable targets.`);
-    return false;
+    if (!json) log(`Backup ${entry.id} has no restorable targets.`);
+    return { ok: false, restored: 0 };
   }
   const stale = [];
   const vanished = [];
@@ -4805,8 +4823,8 @@ async function restoreDirBackup(root, entry, yes) {
     );
   }
   if (toRestore.length === 0) {
-    log(`Backup ${entry.id} has no restorable files left after re-validation.`);
-    return false;
+    if (!json) log(`Backup ${entry.id} has no restorable files left after re-validation.`);
+    return { ok: false, restored: 0 };
   }
   if (stale.length > 0) {
     const detail = stale.map(
@@ -4816,13 +4834,22 @@ async function restoreDirBackup(root, entry, yes) {
       `${stale.length} file(s) at the restore destination are newer than backup ${entry.id} and will be overwritten: ${detail}`
     );
   }
+  if (dryRun) {
+    const rels = toRestore.map((abs) => path26.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}`);
+      log("[dry-run] Nothing was changed.");
+    }
+    return { ok: true, restored: 0, dryRun: true, wouldRestore: rels };
+  }
   if (!yes) {
     const ok = await confirm(
       `Restore ${toRestore.length} file(s) from backup ${entry.id} to their original paths?`
     );
     if (!ok) {
-      log("Cancelled.");
-      return false;
+      if (!json) log("Cancelled.");
+      return { ok: false, restored: 0 };
     }
   }
   let restoredCount = 0;
@@ -4843,23 +4870,20 @@ async function restoreDirBackup(root, entry, yes) {
       `Skipped ${skippedAtWrite.length} file(s) that changed since being checked, right before restoring: ${skippedAtWrite.join(", ")}`
     );
   }
-  log(`Restored ${restoredCount} file(s) from ${entry.id}.`);
-  return restoredCount > 0;
+  if (!json) log(`Restored ${restoredCount} file(s) from ${entry.id}.`);
+  return { ok: restoredCount > 0, restored: restoredCount };
 }
-async function runRestore(root, id, yes) {
+async function runRestore(root, id, yes, json, dryRun) {
   const entries = await listBackups(root);
   const entry = entries.find((e) => e.id === id);
   if (!entry) {
     error(`No backup found with id "${id}". Run \`haus backups list\` to see available backups.`);
-    return false;
+    return { ok: false, restored: 0 };
   }
-  return entry.kind === "lock" ? restoreLockBackup(root, entry, yes) : restoreDirBackup(root, entry, yes);
+  return entry.kind === "lock" ? restoreLockBackup(root, entry, yes, json, dryRun) : restoreDirBackup(root, entry, yes, json, dryRun);
 }
 async function runPrune(root, opts) {
-  if (opts.olderThanDays === void 0 && opts.keep === void 0) {
-    error("Specify --older-than <days> or --keep <n> \u2014 refusing to prune with no bound.");
-    return false;
-  }
+  const json = Boolean(opts.json);
   const entries = await listBackups(root);
   const now = Date.now();
   const toRemove = /* @__PURE__ */ new Set();
@@ -4872,11 +4896,32 @@ async function runPrune(root, opts) {
     if (excess > 0) for (const entry of entries.slice(0, excess)) toRemove.add(entry.id);
   }
   if (toRemove.size === 0) {
-    log("Nothing to prune.");
-    return true;
+    if (!json) log("Nothing to prune.");
+    return {
+      ok: true,
+      removed: [],
+      failed: [],
+      kept: entries.length,
+      ...opts.dryRun ? { dryRun: true, wouldRemove: [] } : {}
+    };
   }
   const removeList = entries.filter((e) => toRemove.has(e.id));
   const keepCount = entries.length - removeList.length;
+  if (opts.dryRun) {
+    if (!json) {
+      log(`[dry-run] Would remove ${removeList.length} backup(s), keeping ${keepCount}:`);
+      for (const e of removeList) log(`  ${e.id}`);
+      log("[dry-run] Nothing was changed.");
+    }
+    return {
+      ok: true,
+      removed: [],
+      failed: [],
+      kept: keepCount,
+      dryRun: true,
+      wouldRemove: removeList.map((e) => e.id)
+    };
+  }
   if (!opts.yes) {
     const ok = await confirm(
       `Remove ${removeList.length} backup(s)?
@@ -4884,8 +4929,8 @@ async function runPrune(root, opts) {
 Keeping ${keepCount}.`
     );
     if (!ok) {
-      log("Cancelled.");
-      return false;
+      if (!json) log("Cancelled.");
+      return { ok: false, removed: [], failed: [], kept: entries.length, cancelled: true };
     }
   }
   const removed = [];
@@ -4898,37 +4943,52 @@ Keeping ${keepCount}.`
       failed.push({ id: entry.id, message: err instanceof Error ? err.message : String(err) });
     }
   }
-  log(`Removed ${removed.length} backup(s), kept ${entries.length - removed.length}.`);
+  if (!json) log(`Removed ${removed.length} backup(s), kept ${entries.length - removed.length}.`);
   if (failed.length > 0) {
     warn(
       `Failed to remove ${failed.length} backup(s): ${failed.map((f) => `${f.id} (${f.message})`).join(", ")}`
     );
-    return false;
   }
-  return true;
+  return {
+    ok: failed.length === 0,
+    removed,
+    failed,
+    kept: entries.length - removed.length
+  };
 }
 async function runBackups(action, opts = {}) {
   const root = opts.root ?? process.cwd();
+  const json = Boolean(opts.json);
   if (action === "list") {
-    await runList(root);
+    await runList(root, json);
     return;
   }
   if (action === "restore") {
     if (!opts.id) {
+      if (json) log(JSON.stringify({ ok: false, error: "Usage: haus backups restore <id>" }));
       error("Usage: haus backups restore <id>");
       process.exitCode = 1;
       return;
     }
-    if (!await runRestore(root, opts.id, Boolean(opts.yes))) process.exitCode = 1;
+    const result2 = await runRestore(root, opts.id, Boolean(opts.yes), json, Boolean(opts.dryRun));
+    if (json) log(JSON.stringify({ id: opts.id, ...result2 }, null, 2));
+    if (!result2.ok) process.exitCode = 1;
+    return;
+  }
+  if (opts.olderThan === void 0 && opts.keep === void 0) {
+    const message = "Specify --older-than <days> or --keep <n> \u2014 refusing to prune with no bound.";
+    if (json) log(JSON.stringify({ ok: false, error: message }));
+    error(message);
+    process.exitCode = 1;
     return;
   }
   let olderThanDays;
   if (opts.olderThan !== void 0) {
     const n = Number(opts.olderThan);
     if (!Number.isFinite(n) || n < 0) {
-      error(
-        `Invalid --older-than value "${opts.olderThan}" \u2014 expected a non-negative number of days.`
-      );
+      const message = `Invalid --older-than value "${opts.olderThan}" \u2014 expected a non-negative number of days.`;
+      if (json) log(JSON.stringify({ ok: false, error: message }));
+      error(message);
       process.exitCode = 1;
       return;
     }
@@ -4938,13 +4998,23 @@ async function runBackups(action, opts = {}) {
   if (opts.keep !== void 0) {
     const n = Number(opts.keep);
     if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) {
-      error(`Invalid --keep value "${opts.keep}" \u2014 expected a non-negative integer.`);
+      const message = `Invalid --keep value "${opts.keep}" \u2014 expected a non-negative integer.`;
+      if (json) log(JSON.stringify({ ok: false, error: message }));
+      error(message);
       process.exitCode = 1;
       return;
     }
     keep = n;
   }
-  if (!await runPrune(root, { olderThanDays, keep, yes: Boolean(opts.yes) })) process.exitCode = 1;
+  const result = await runPrune(root, {
+    olderThanDays,
+    keep,
+    yes: Boolean(opts.yes),
+    json,
+    dryRun: Boolean(opts.dryRun)
+  });
+  if (json) log(JSON.stringify(result, null, 2));
+  if (!result.ok) process.exitCode = 1;
 }
 
 // src/commands/catalog-audit.ts
@@ -6194,12 +6264,19 @@ async function runDoctor(options) {
   const root = process.cwd();
   if (options?.hooks) {
     const hooks2 = await verifyProjectSettingsHooksContract(root);
-    if (hooks2.skipped) {
-      error(`Haus doctor --hooks: ${hooks2.message}`);
-      process.exitCode = 1;
+    const hooksOk = !hooks2.skipped && hooks2.ok;
+    if (options.json) {
+      log(
+        JSON.stringify(
+          { ok: hooksOk, skipped: Boolean(hooks2.skipped), message: hooks2.message },
+          null,
+          2
+        )
+      );
+      if (!hooksOk) process.exitCode = 1;
       return;
     }
-    if (!hooks2.ok) {
+    if (!hooksOk) {
       error(`Haus doctor --hooks: ${hooks2.message}`);
       process.exitCode = 1;
       return;
@@ -6339,10 +6416,17 @@ async function runDoctor(options) {
       const templateContent = await readText(templatePath);
       const verdict = checkManagedTamper(bodyContent, storedHashMatch?.[1], templateContent ?? null);
       if (verdict.status === "tampered" || verdict.status === "legacy-diverged") {
+        let diffNote = "";
+        if (templateContent != null) {
+          const summary = summarizeDiff(
+            createUnifiedDiff(".haus-workflow/WORKFLOW.md", bodyContent, templateContent)
+          );
+          diffNote = ` \u2014 restoring would discard ${summary.deletions} local line(s) and add ${summary.additions}`;
+        }
         flag(
-          "- .haus-workflow/WORKFLOW.md: modified locally (run `haus apply --write --force` to restore)",
-          "The workflow standard file was edited after haus wrote it",
-          "haus apply --write --force"
+          `- .haus-workflow/WORKFLOW.md: modified locally${diffNote} (preview: \`haus apply --dry-run\`; restore: \`haus apply --write --force\`)`,
+          `The workflow standard file was edited after haus wrote it${diffNote}`,
+          "preview with `haus apply --dry-run`, then `haus apply --write --force` to restore"
         );
       } else if (verdict.status === "stale") {
         suggest(
@@ -6524,6 +6608,40 @@ async function runDoctor(options) {
       }
     }
   }
+  {
+    const lockRows = await readJson(
+      hausPath(root, "haus.lock.json")
+    );
+    if (lockRows && lockRows.length > 0) {
+      const catalogItems = await loadCatalog(root);
+      const byId = new Map(catalogItems.map((item) => [item.id, item]));
+      const activePinIds = activePins.map((pin) => pin.id);
+      const lingering = [];
+      for (const row of lockRows) {
+        if (typeof row.id !== "string") continue;
+        if (isSupersededByPlugin(row.id, activePinIds)) continue;
+        const manifestItem = byId.get(row.id);
+        if (manifestItem && manifestItem.reviewStatus !== "deprecated") continue;
+        let onDisk = false;
+        for (const rel of row.paths ?? []) {
+          const abs = resolveContainedPath(root, rel);
+          if (abs !== null && await fs30.pathExists(abs)) {
+            onDisk = true;
+            break;
+          }
+        }
+        if (onDisk) lingering.push(row.id);
+      }
+      if (lingering.length > 0) {
+        const idList = `${lingering.slice(0, 3).join(", ")}${lingering.length > 3 ? ", \u2026" : ""}`;
+        suggest(
+          `- CATALOG ITEMS: ${lingering.length} installed item(s) are removed or deprecated in the current catalog (${idList}) \u2014 pre-0.30.0 CLIs never pruned these`,
+          `${lingering.length} installed item(s) no longer exist in the catalog (removed or deprecated)`,
+          "haus update (prunes them when unmodified; see docs/runbook.md for locally-edited copies)"
+        );
+      }
+    }
+  }
   const pkgJson = await readJson(path40.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
@@ -6539,6 +6657,10 @@ async function runDoctor(options) {
     ok(`- CLI: ${currentVersion} (version check unavailable)`);
   }
   if (attention.length > 0) process.exitCode = 1;
+  if (options?.json) {
+    log(JSON.stringify({ ok: attention.length === 0, attention, suggestions, detail }, null, 2));
+    return;
+  }
   if (attention.length === 0) {
     log("\u2705 Your project is set up and healthy.");
   } else {
@@ -6968,6 +7090,31 @@ async function hasLocalOverrides(root) {
   }
 }
 
+// src/update/release-notes.ts
+var RELEASES_API_BASE = "https://api.github.com/repos/WeAreHausTech/haus-workflow/releases/tags";
+var MAX_NOTE_LINES = 40;
+async function fetchReleaseNotes(version) {
+  try {
+    const headers = await getGithubApiHeaders();
+    const res = await fetch(`${RELEASES_API_BASE}/v${version}`, {
+      headers,
+      // Same bound npm-version.ts uses — best-effort must also mean bounded-time.
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) return null;
+    const release = await res.json();
+    if (typeof release.body !== "string" || release.body.trim().length === 0) return null;
+    const lines = release.body.trim().split("\n");
+    if (lines.length <= MAX_NOTE_LINES) return lines.join("\n");
+    return [
+      ...lines.slice(0, MAX_NOTE_LINES),
+      `\u2026 (${lines.length - MAX_NOTE_LINES} more lines)`
+    ].join("\n");
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/update.ts
 var NPM_PACKAGE_NAME2 = "@haus-tech/haus-workflow";
 async function runUpdate(options) {
@@ -7032,6 +7179,13 @@ async function runUpdate(options) {
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
     log(`npm update available: ${currentVersion} \u2192 ${npmStatus.latest}`);
     log(`Run: npm install -g ${NPM_PACKAGE_NAME2}`);
+    const notes = await fetchReleaseNotes(npmStatus.latest);
+    if (notes !== null) {
+      log(`
+What changed in ${npmStatus.latest}:`);
+      log(notes);
+      log("");
+    }
   } else if (npmStatus.latest !== null) {
     log(`npm package up to date: ${currentVersion}`);
   }
@@ -8118,13 +8272,6 @@ function applyCoInstallSuppression(recommended, skipped) {
       message: "Skip TDD superpower when a stack testing skill is selected",
       signal: "co-install:stack-testing"
     },
-    {
-      suppress: "haus.superpowers-specifying-gates",
-      whenAnyRecommended: ["haus.superpowers-checking-gates"],
-      code: "co-install-gate-workflow",
-      message: "Skip specifying-gates when checking-gates is selected",
-      signal: "co-install:checking-gates"
-    },
     {
       suppress: "haus.ecc-redis-patterns",
       whenAnyRecommended: ["haus.redis-redis-connections"],
@@ -8687,6 +8834,7 @@ async function runRecommend(options) {
     );
   }
   for (const w of result.warnings) log(`- WARN: ${w}`);
+  log("Run `haus explain-recommendation` for per-item reasons and skip explanations.");
 }
 
 // src/commands/refresh.ts
@@ -8996,6 +9144,12 @@ async function runUndo(options) {
       `(preserving ${lockPreserved.length} locally-modified catalog item file(s) \u2014 not shown above)`
     );
   }
+  if (options.dryRun) {
+    log(`[dry-run] Would remove:
+  ${summaryParts.join("\n  ")}`);
+    log("[dry-run] User-owned .claude/ files would be preserved. Nothing was changed.");
+    return;
+  }
   if (!options.yes) {
     const ok = await confirm(
       `Remove haus-managed files?
@@ -9121,6 +9275,21 @@ function printUninstallResult(result) {
 // src/commands/uninstall.ts
 async function runUninstallCommand(options) {
   try {
+    if (options.dryRun) {
+      const manifest = await readManifest();
+      if (!manifest) {
+        log("[dry-run] No install manifest found \u2014 nothing would be removed.");
+        return;
+      }
+      if (manifest.files.length > 0) {
+        log(`[dry-run] Would remove ${manifest.files.length} haus-managed file(s) from ~/.claude/:`);
+        for (const f of manifest.files) log(`  ${f.destPath}`);
+      }
+      log(
+        "[dry-run] Would strip haus hook entries from ~/.claude/settings.json and remove the install manifest. Nothing was changed."
+      );
+      return;
+    }
     if (!options.yes) {
       const manifest = await readManifest();
       if (manifest) {
@@ -10338,6 +10507,9 @@ async function runRemove(opts) {
 }
 
 // src/commands/workspace/worktree.ts
+function emitJson(result) {
+  log(JSON.stringify(result, null, 2));
+}
 function describeInstall(hydration) {
   if (hydration.install.plan.manager === "none") return "no install step (no recognized lockfile)";
   if (!hydration.install.ran)
@@ -10346,7 +10518,8 @@ function describeInstall(hydration) {
 }
 async function handleAdd(opts) {
   if (!opts.slug) {
-    error("Usage: haus workspace worktree add <slug>");
+    if (opts.json) emitJson({ ok: false, error: "Usage: haus workspace worktree add <slug>" });
+    else error("Usage: haus workspace worktree add <slug>");
     process.exitCode = 1;
     return;
   }
@@ -10359,10 +10532,16 @@ async function handleAdd(opts) {
   };
   const result = await runAdd(addOpts);
   if ("error" in result) {
-    error(result.error);
+    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.dryRun) {
     log(
       `[dry-run] Would create the workspace worktree at ${result.worktreePath} on branch "${result.branch}" (${result.workspaceWorktree.branchAction}).`
@@ -10402,10 +10581,16 @@ async function handleHydrate(opts) {
   };
   const result = await runHydrateWorktree(hydrateOpts);
   if (!result.ok && "error" in result) {
-    error(result.error);
+    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.dryRun) {
     log(`[dry-run] Would hydrate "${result.slug}":`);
     for (const r of result.results) {
@@ -10427,7 +10612,8 @@ async function handleHydrate(opts) {
 }
 async function handleRemove(opts) {
   if (!opts.slug) {
-    error("Usage: haus workspace worktree remove <slug>");
+    if (opts.json) emitJson({ ok: false, error: "Usage: haus workspace worktree remove <slug>" });
+    else error("Usage: haus workspace worktree remove <slug>");
     process.exitCode = 1;
     return;
   }
@@ -10437,6 +10623,11 @@ async function handleRemove(opts) {
     dryRun: Boolean(opts.dryRun)
   };
   const result = await runRemove(removeOpts);
+  if (opts.json) {
+    emitJson(result);
+    if (!result.ok || "removed" in result && result.failed.length > 0) process.exitCode = 1;
+    return;
+  }
   if (!result.ok && "error" in result) {
     error(result.error);
     process.exitCode = 1;
@@ -10461,8 +10652,13 @@ async function handleRemove(opts) {
     }
   }
 }
-async function handleList() {
+async function handleList(opts) {
   const result = await runList2();
+  if (opts.json) {
+    emitJson(result);
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
   if (!result.ok) {
     error(result.error);
     process.exitCode = 1;
@@ -10533,7 +10729,7 @@ async function runWorktree(action, opts = {}) {
     case "remove":
       return handleRemove(opts);
     case "list":
-      return handleList();
+      return handleList(opts);
     case "doctor":
       return handleDoctor(opts);
   }
@@ -11361,6 +11557,52 @@ async function runWorkspaceUndo(workspaceRoot, options = {}) {
   if (config.repos.length === 0) {
     log(`No repos configured in ${WORKSPACE_FILE}.`);
   }
+  if (options.dryRun) {
+    for (const repo of config.repos) {
+      const repoRoot = path71.resolve(workspaceRoot, repo.path);
+      log(`
+\u2192 ${repo.name} (${repo.path})`);
+      try {
+        if (!existsSync9(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+          throw new Error(`Repo path is not a directory: ${repo.path}`);
+        }
+        await runUndo({ dryRun: true, root: repoRoot });
+      } catch (err) {
+        warn(
+          `[dry-run] Undo preview failed for ${repo.name}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const linkedContext2 = await readLinkedContext(workspaceRoot);
+    for (const entry of linkedContext2) {
+      const abs = resolveContainedPath(workspaceRoot, entry.path);
+      if (abs === null) {
+        warn(`Refusing to remove linked context path outside the workspace root: ${entry.path}`);
+        continue;
+      }
+      if (await fs48.pathExists(abs)) {
+        log(`[dry-run] Would remove ${entry.path} (linked ${entry.type} from ${entry.repo})`);
+      }
+    }
+    const workspaceArtifacts = [
+      ...WORKSPACE_AGGREGATE_FILES.map((rel) => hausPath(workspaceRoot, rel)),
+      manifestPath(workspaceRoot),
+      hausPath(workspaceRoot, "WORKSPACE.md")
+    ];
+    for (const abs of workspaceArtifacts) {
+      if (await fs48.pathExists(abs)) {
+        log(`[dry-run] Would remove ${path71.relative(workspaceRoot, abs)}`);
+      }
+    }
+    if (!await fs48.pathExists(hausPath(workspaceRoot, "WORKSPACE.md"))) {
+      const claudeMd = await readText(path71.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");
+      }
+    }
+    log(`[dry-run] ${WORKSPACE_FILE} would be left in place. Nothing was changed.`);
+    return;
+  }
   if (!options.yes) {
     const ok = await confirm(
       `Undo haus setup for ${config.repos.length} repo(s) in this workspace, plus workspace-root artifacts?`
@@ -11560,7 +11802,7 @@ async function runWorkspace(action, options = {}) {
       await runWorkspaceDoctor(workspaceRoot, { json: options.json });
       return;
     case "undo":
-      await runWorkspaceUndo(workspaceRoot, { yes: options.yes });
+      await runWorkspaceUndo(workspaceRoot, { yes: options.yes, dryRun: options.dryRun });
       return;
     case "link-context":
       await runWorkspaceLinkContext(workspaceRoot, { write: options.write, json: options.json });
@@ -11608,7 +11850,7 @@ program.command("setup-project").description("Fast full setup: scan, recommend,
 ).action(runSetupProject);
 program.command("doctor").description(
   "Validate project setup: hooks contract, managed files, cache freshness, CLI version"
-).option("--hooks", "Verify .claude/settings.json matches the hook contract").action(runDoctor);
+).option("--hooks", "Verify .claude/settings.json matches the hook contract").option("--json", "Emit all findings as one JSON document on stdout instead of human output").action(runDoctor);
 program.command("fetch-refs").description("Fetch and cache llms.txt content from catalog item references").option("--all", "Fetch for all catalog items (default)").option("--id <id>", "Fetch for a single catalog item by id").option("--json", "Emit machine-readable JSON summary to stdout").action(runFetchRefs);
 program.command("apply").description("Write recommended catalog items and core Claude files to .claude/").option("--dry-run").option("--write").option("--select", "Interactively select catalog items before applying").option(
   "--ids <ids...>",
@@ -11623,12 +11865,20 @@ program.command("apply").description("Write recommended catalog items and core C
   "--prune",
   "Remove lock-tracked catalog items no longer in the current recommendation (hash-gated, backed up first)"
 ).action(runApply);
-program.command("undo").description("Remove haus-managed project files; preserves user-owned .claude/ content").option("-y, --yes", "Skip confirmation").action(runUndo);
+program.command("undo").description("Remove haus-managed project files; preserves user-owned .claude/ content").option("-y, --yes", "Skip confirmation").option("--dry-run", "Print what would be removed without deleting anything").action(runUndo);
 var backups = program.command("backups").description("List, restore, or prune backups under .haus-workflow/backups/");
-backups.command("list").description("List backups under .haus-workflow/backups/").action(() => runBackups("list"));
-backups.command("restore <id>").description("Restore a specific backup by id (see `haus backups list`)").option("-y, --yes", "Skip confirmation").action((id, opts) => runBackups("restore", { id, yes: opts.yes }));
-backups.command("prune").description("Delete old backups by age and/or count (requires --older-than or --keep)").option("--older-than <days>", "Remove backups older than N days").option("--keep <n>", "Keep only the N most recent backups").option("-y, --yes", "Skip confirmation").action(
-  (opts) => runBackups("prune", { olderThan: opts.olderThan, keep: opts.keep, yes: opts.yes })
+backups.command("list").description("List backups under .haus-workflow/backups/").option("--json", "Emit the backup entries as JSON (newest first)").action((opts) => runBackups("list", { json: opts.json }));
+backups.command("restore <id>").description("Restore a specific backup by id (see `haus backups list`)").option("-y, --yes", "Skip confirmation").option("--json", "Emit a machine-readable result (JSON-only stdout; warnings on stderr)").option("--dry-run", "Print what would be restored without writing anything").action(
+  (id, opts) => runBackups("restore", { id, yes: opts.yes, json: opts.json, dryRun: opts.dryRun })
+);
+backups.command("prune").description("Delete old backups by age and/or count (requires --older-than or --keep)").option("--older-than <days>", "Remove backups older than N days").option("--keep <n>", "Keep only the N most recent backups").option("-y, --yes", "Skip confirmation").option("--json", "Emit a machine-readable result (JSON-only stdout; warnings on stderr)").option("--dry-run", "Print what would be pruned without deleting anything").action(
+  (opts) => runBackups("prune", {
+    olderThan: opts.olderThan,
+    dryRun: opts.dryRun,
+    keep: opts.keep,
+    yes: opts.yes,
+    json: opts.json
+  })
 );
 program.command("explain-recommendation").description("Print a per-item breakdown of the current recommendation, with skip reasons").option("--json").action(runExplainRecommendation);
 program.command("init").description("First-run setup; delegates to setup-project if .haus-workflow/ does not exist").option("--json").action(runInit);
@@ -11646,7 +11896,7 @@ program.command("install").description("Seed ~/.claude/ with Haus-managed skills
 program.command("scaffold [ids...]").description(
   "Copy catalog config items (ESLint, Prettier) into the project root. Pass item IDs to scaffold specific items, or omit to scaffold all available config items."
 ).option("--force", "Overwrite existing files").option("--dry-run", "Preview what would be written without changing anything").option("--root <path>", "Project root (defaults to cwd)", process.cwd()).action(runScaffold);
-program.command("uninstall").description("Remove Haus-managed skills, agents, and hook entries from ~/.claude/").option("--force").option("-y, --yes", "Skip confirmation").action(runUninstallCommand);
+program.command("uninstall").description("Remove Haus-managed skills, agents, and hook entries from ~/.claude/").option("--force").option("-y, --yes", "Skip confirmation").option("--dry-run", "Print what would be removed without deleting anything").action(runUninstallCommand);
 var guard = program.command("guard").description("PreToolUse hook guards: block dangerous bash commands and sensitive file access");
 guard.command("file-access").description("Block reads/edits of sensitive paths (run by the Claude Code hook)").option("--from-hook").action((opts) => runGuard("file-access", opts));
 guard.command("bash").description("Block dangerous shell commands (run by the Claude Code hook)").option("--from-hook").action((opts) => runGuard("bash", opts));
@@ -11668,7 +11918,7 @@ workspace.command("discover").description("Auto-find member repos and write/merg
 workspace.command("scan").description("Aggregate a cross-repo summary from a fast scan of each repo").option("--json", "Output the written artifact paths as JSON").action((opts) => runWorkspace("scan", opts));
 workspace.command("setup").description("Per-repo setup loop + workspace layer + manifest").option("--write", "Apply changes (default previews only)").option("--dry-run", "Preview changes without writing").option("--json", "Emit machine-readable per-repo output").option("--continue-on-error", "Keep going past a failed repo (default fail-fast)").option("--only <names>", "Restrict to comma-separated repo names").action((opts) => runWorkspace("setup", opts));
 workspace.command("doctor").description("Report workspace drift against the manifest").option("--json", "Output the manifest and drift array as JSON").action((opts) => runWorkspace("doctor", opts));
-workspace.command("undo").description("Revert haus setup for every configured repo, plus workspace-root artifacts").option("-y, --yes", "Skip confirmation").action((opts) => runWorkspace("undo", opts));
+workspace.command("undo").description("Revert haus setup for every configured repo, plus workspace-root artifacts").option("-y, --yes", "Skip confirmation").option("--dry-run", "Print what would be removed without deleting anything").action((opts) => runWorkspace("undo", opts));
 workspace.command("link-context").description(
   "Copy each member repo's skill/agent/command into the workspace root's .claude/, prefixed to avoid collisions"
 ).option("--write", "Persist copies + manifest + gitignore (default previews only)").option("--json", "Output the link result as JSON").action((opts) => runWorkspace("link-context", opts));
@@ -11677,29 +11927,31 @@ var worktree = workspace.command("worktree").description(
 );
 worktree.command("add <slug>").description(
   "Create a workspace worktree plus one member worktree per repo, on a mirrored branch"
-).option("--branch <name>", "Branch to create/checkout (default: the slug)").option("--only <repos>", "Restrict to comma- or space-separated member ids/folders").option("--no-hydrate", "Skip hydration (CoW clone + install-reconciliation)").option("--dry-run", "Preview without writing or running anything").action(
+).option("--branch <name>", "Branch to create/checkout (default: the slug)").option("--only <repos>", "Restrict to comma- or space-separated member ids/folders").option("--no-hydrate", "Skip hydration (CoW clone + install-reconciliation)").option("--dry-run", "Preview without writing or running anything").option("--json", "Emit the structured add result as JSON").action(
   (slug, opts) => runWorktree("add", {
     slug,
     branch: opts.branch,
     only: opts.only,
     hydrate: opts.hydrate,
-    dryRun: opts.dryRun
+    dryRun: opts.dryRun,
+    json: opts.json
   })
 );
 worktree.command("hydrate").description("Re-run CoW clone + install-reconciliation for the current workspace worktree").option("--only <repos>", "Restrict to comma- or space-separated member ids/folders").option("--force", "Re-clone hydration targets even if already present").option(
   "--materialize",
   "Also `git worktree add` any member missing entirely (e.g. a worktree created by plain `git worktree add` outside haus) before hydrating it"
-).option("--dry-run", "Preview without writing or running anything").action(
+).option("--dry-run", "Preview without writing or running anything").option("--json", "Emit the structured hydrate result as JSON").action(
   (opts) => runWorktree("hydrate", {
     only: opts.only,
     force: opts.force,
     materialize: opts.materialize,
-    dryRun: opts.dryRun
+    dryRun: opts.dryRun,
+    json: opts.json
   })
 );
-worktree.command("list").description("List materialized workspace worktrees and their member status").action(() => runWorktree("list"));
-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").action(
-  (slug, opts) => runWorktree("remove", { slug, force: opts.force, dryRun: opts.dryRun })
+worktree.command("list").description("List materialized workspace worktrees and their member status").option("--json", "Emit the structured list result as JSON").action((opts) => runWorktree("list", { json: opts.json }));
+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("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) => {

package/library/catalog/manifest.json

@@ -1,5 +1,14 @@
 {
-  "version": "4.4.1",
+  "version": "5.0.0",
+  "globalPlugins": [
+    {
+      "id": "superpowers",
+      "plugin": "superpowers-extended-cc",
+      "marketplace": "superpowers-extended-cc-marketplace",
+      "url": "https://github.com/pcvelz/superpowers.git",
+      "ref": "v6.4.0"
+    }
+  ],
   "items": [
     {
       "id": "haus.agentic-workflow-standard",
@@ -1539,7 +1548,7 @@
     },
     {
       "id": "haus.package-manager-yarn4-pnpm89",
-      "version": "1.0.1",
+      "version": "1.0.2",
       "source": "haus",
       "type": "skill",
       "path": "skills/haus-owned/package-managers/package-manager-yarn4-pnpm89",
@@ -2102,406 +2111,6 @@
         }
       ]
     },
-    {
-      "id": "haus.superpowers-brainstorming",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/brainstorming",
-      "title": "Superpowers Brainstorming",
-      "purpose": "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.",
-      "whenToUse": "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.",
-      "whenNotToUse": "Do not use for mechanical edits, bug fixes with known cause, or read-only questions.",
-      "tags": ["workflow", "core-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 2887,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/brainstorming",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-checking-gates",
-      "version": "1.0.1",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/checking-gates",
-      "title": "Superpowers Checking Gates",
-      "purpose": "Use when picking up a user-gate task OR when a hook demands re-validation. Runs the \"do I know HOW?\" self-check; if the HOW is clear, executes the verification and posts evidence; if not, hands off to specifying-gates. Kept deliberately separate from executing-plans so that without the opt-in hook, the main flow stays untouched.",
-      "whenToUse": "Use when picking up a user-gate task OR when a hook demands re-validation. Runs the \"do I know HOW?\" self-check; if the HOW is clear, executes the verification and posts evidence; if not, hands off to specifying-gates. Kept deliberately separate from executing-plans so that without the opt-in hook, the main flow stays untouched.",
-      "whenNotToUse": "Do not use when the user-gate hook is not registered or the task is not user-gated.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1228,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/checking-gates",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-dispatching-parallel-agents",
-      "version": "1.0.1",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/dispatching-parallel-agents",
-      "title": "Superpowers Dispatching Parallel Agents",
-      "purpose": "Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies",
-      "whenToUse": "Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies",
-      "whenNotToUse": "Do not use when tasks share state or must run sequentially.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1793,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/dispatching-parallel-agents",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-executing-plans",
-      "version": "1.0.2",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/executing-plans",
-      "title": "Superpowers Executing Plans",
-      "purpose": "Use when you have a written implementation plan to execute in a separate session with review checkpoints",
-      "whenToUse": "Use when you have a written implementation plan to execute in a separate session with review checkpoints",
-      "whenNotToUse": "Do not use before a written plan exists or for single-step trivial changes.",
-      "tags": ["workflow", "core-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1601,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/fc6d376756b605f35c399b1b00a16bb27ec55171/skills/executing-plans",
-      "ecosystem": "superpowers",
-      "pinnedRef": "fc6d376756b605f35c399b1b00a16bb27ec55171"
-    },
-    {
-      "id": "haus.superpowers-finishing-a-development-branch",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/finishing-a-development-branch",
-      "title": "Superpowers Finishing A Development Branch",
-      "purpose": "Use when implementation is complete, all tests pass, and you need to decide how to integrate the work",
-      "whenToUse": "Use when implementation is complete, all tests pass, and you need to decide how to integrate the work",
-      "whenNotToUse": "Do not use while implementation or verification is still incomplete.",
-      "tags": ["workflow", "quality"],
-      "repoRoles": [],
-      "tokenEstimate": 1756,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/finishing-a-development-branch",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-receiving-code-review",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/receiving-code-review",
-      "title": "Superpowers Receiving Code Review",
-      "purpose": "Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation",
-      "whenToUse": "Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation",
-      "whenNotToUse": "Do not use to blindly apply feedback without technical verification.",
-      "tags": ["review", "review-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1551,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/receiving-code-review",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-requesting-code-review",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/requesting-code-review",
-      "title": "Superpowers Requesting Code Review",
-      "purpose": "Use when completing tasks, implementing major features, or before merging to verify work meets requirements",
-      "whenToUse": "Use when completing tasks, implementing major features, or before merging to verify work meets requirements",
-      "whenNotToUse": "Do not use for trivial one-line fixes with no review surface.",
-      "tags": ["review", "review-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 739,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/requesting-code-review",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-specifying-gates",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/specifying-gates",
-      "title": "Superpowers Specifying Gates",
-      "purpose": "Use when a user-gate task has requiresUserSpecification=true OR the agent's \"do I know HOW?\" self-check returns no. Locks down verification mechanics through a short AskUserQuestion sequence and writes the answers back into the task's metadata. Does NOT run the verification itself.",
-      "whenToUse": "Use when a user-gate task has requiresUserSpecification=true OR the agent's \"do I know HOW?\" self-check returns no. Locks down verification mechanics through a short AskUserQuestion sequence and writes the answers back into the task's metadata. Does NOT run the verification itself.",
-      "whenNotToUse": "Do not use when verification mechanics are already specified or hook is off.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1785,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/specifying-gates",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-subagent-driven-development",
-      "version": "1.0.4",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/subagent-driven-development",
-      "title": "Superpowers Subagent Driven Development",
-      "purpose": "Use when executing implementation plans with independent tasks in the current session",
-      "whenToUse": "Use when executing implementation plans with independent tasks in the current session",
-      "whenNotToUse": "Do not use for tightly coupled sequential work or when subagents are unavailable.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 8024,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/subagent-driven-development",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-systematic-debugging",
-      "version": "1.0.1",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/systematic-debugging",
-      "title": "Superpowers Systematic Debugging",
-      "purpose": "Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes",
-      "whenToUse": "Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes",
-      "whenNotToUse": "Do not use to guess fixes without reproducing or investigating the failure.",
-      "tags": ["workflow", "quality"],
-      "repoRoles": [],
-      "tokenEstimate": 2373,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/systematic-debugging",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-test-driven-development",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/test-driven-development",
-      "title": "Superpowers Test Driven Development",
-      "purpose": "Use when implementing any feature or bugfix, before writing implementation code",
-      "whenToUse": "Use when implementing any feature or bugfix, before writing implementation code",
-      "whenNotToUse": "Do not use for exploratory spikes, docs-only changes, or throwaway prototypes.",
-      "tags": ["testing", "workflow"],
-      "repoRoles": [],
-      "tokenEstimate": 2254,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/test-driven-development",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-using-git-worktrees",
-      "version": "1.0.4",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/using-git-worktrees",
-      "title": "Superpowers Using Git Worktrees",
-      "purpose": "Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback",
-      "whenToUse": "Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback",
-      "whenNotToUse": "Do not use when current workspace isolation is already sufficient.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1848,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/using-git-worktrees",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-using-superpowers",
-      "version": "1.0.2",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/using-superpowers",
-      "title": "Superpowers Using Superpowers",
-      "purpose": "Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions",
-      "whenToUse": "Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions",
-      "whenNotToUse": "Do not skip when any skill might apply — this establishes the skill workflow.",
-      "tags": ["workflow", "core-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 1185,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/using-superpowers",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-verification-before-completion",
-      "version": "1.0.1",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/verification-before-completion",
-      "title": "Superpowers Verification Before Completion",
-      "purpose": "Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always",
-      "whenToUse": "Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always",
-      "whenNotToUse": "Do not use to claim success before running the relevant verification commands.",
-      "tags": ["quality", "workflow"],
-      "repoRoles": [],
-      "tokenEstimate": 912,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/verification-before-completion",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
-    {
-      "id": "haus.superpowers-writing-plans",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/writing-plans",
-      "title": "Superpowers Writing Plans",
-      "purpose": "Use when you have a spec or requirements for a multi-step task, before touching code",
-      "whenToUse": "Use when you have a spec or requirements for a multi-step task, before touching code",
-      "whenNotToUse": "Do not use for single-step tasks that need no multi-step plan.",
-      "tags": ["workflow", "core-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 5850,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/fc6d376756b605f35c399b1b00a16bb27ec55171/skills/writing-plans",
-      "ecosystem": "superpowers",
-      "pinnedRef": "fc6d376756b605f35c399b1b00a16bb27ec55171"
-    },
-    {
-      "id": "haus.superpowers-writing-skills",
-      "version": "1.0.3",
-      "source": "curated",
-      "type": "skill",
-      "path": "skills/superpowers/writing-skills",
-      "title": "Superpowers Writing Skills",
-      "purpose": "Use when creating new skills, editing existing skills, or verifying skills work before deployment",
-      "whenToUse": "Use when creating new skills, editing existing skills, or verifying skills work before deployment",
-      "whenNotToUse": "Do not use for routine code changes unrelated to skill authoring.",
-      "tags": ["workflow", "workflow-skill"],
-      "repoRoles": [],
-      "tokenEstimate": 5555,
-      "installMode": "copy-selected",
-      "default": true,
-      "reviewStatus": "approved",
-      "riskLevel": "low",
-      "useMode": "copy",
-      "license": "MIT",
-      "licenseConfidence": "high",
-      "originSourceId": "superpowers-pcvelz",
-      "originUrl": "https://github.com/pcvelz/superpowers/tree/e748382ff059bcc0219dae8cc1059ef7f3a938d5/skills/writing-skills",
-      "ecosystem": "superpowers",
-      "pinnedRef": "e748382ff059bcc0219dae8cc1059ef7f3a938d5"
-    },
     {
       "id": "haus.tanstack-query-router-patterns",
       "version": "1.0.2",
@@ -3346,7 +2955,7 @@
       "purpose": "Write modern, high-performance C# code using records, pattern matching, value objects, async/await, Span<T>/Memory<T>, and best-practice API design patterns. Emphasizes functional-style programming with C# 12+ features.",
       "whenToUse": "Write modern, high-performance C# code using records, pattern matching, value objects, async/await, Span<T>/Memory<T>, and best-practice API design patterns. Emphasizes functional-style programming with C# 12+ features.",
       "whenNotToUse": "Do not use when a more specific skill or command applies.",
-      "tags": ["dotnet", "csharp", "backend"],
+      "tags": ["dotnet", "csharp"],
       "repoRoles": [],
       "tokenEstimate": 2664,
       "installMode": "copy-selected",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haus-tech/haus-workflow",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Haus AI workflow CLI for Claude Code.",
   "type": "module",
   "bin": {