@haus-tech/haus-workflow 0.19.0 → 0.21.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.21.0](https://github.com/WeAreHausTech/haus-workflow/compare/v0.20.0...v0.21.0) (2026-06-11)
+
+### Features
+
+- **clone:** add project:cloneandsetup command for cloning and setting up repos ([#94](https://github.com/WeAreHausTech/haus-workflow/issues/94)) ([3e7d279](https://github.com/WeAreHausTech/haus-workflow/commit/3e7d2799433106615a1bf25e94be3402f4eb69d2))
+
+### Bug Fixes
+
+- **audit:** correctness hardening ([#90](https://github.com/WeAreHausTech/haus-workflow/issues/90)) ([823b98d](https://github.com/WeAreHausTech/haus-workflow/commit/823b98dc9e4deb2d28ecc5b57b721e80af555a05))
+
+## [0.20.0](https://github.com/WeAreHausTech/haus-workflow/compare/v0.19.0...v0.20.0) (2026-06-11)
+
+### Features
+
+- **clone:** enhance user confirmation prompts before cloning repositories ([#93](https://github.com/WeAreHausTech/haus-workflow/issues/93)) ([1f3e6b4](https://github.com/WeAreHausTech/haus-workflow/commit/1f3e6b4c4e97b2ab7b979ab4fbcab8ce6cda3f32))
+
 ## [0.19.0](https://github.com/WeAreHausTech/haus-workflow/compare/v0.18.2...v0.19.0) (2026-06-11)
 
 ### Features

package/dist/cli.js

@@ -332,26 +332,39 @@ async function readSettings() {
 async function writeSettings(settings) {
   await writeJson(settingsJsonPath(), settings);
 }
+function collectEventHookCommands(entries) {
+  const cmds = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const h of entry.hooks ?? []) {
+      if (h.command) cmds.add(h.command);
+    }
+  }
+  return cmds;
+}
 function mergeHooks(settings, fragments) {
   const existing = settings._haus?.hooks ?? [];
   const existingCommands = settings._haus?.hookCommands ?? [];
-  const existingSet = new Set(existing);
   const updated = { ...settings };
   updated.hooks = { ...settings.hooks ?? {} };
   const addedIds = [];
   const addedCommands = [];
   for (const fragment of fragments) {
     if (fragment.gate !== "keep") continue;
-    if (existingSet.has(fragment.id)) continue;
     const event = fragment.event;
+    const eventEntries = updated.hooks[event] ?? [];
+    const presentCommands = collectEventHookCommands(eventEntries);
+    if (presentCommands.has(fragment.command)) {
+      if (!existingCommands.includes(fragment.command)) addedCommands.push(fragment.command);
+      continue;
+    }
     if (!updated.hooks[event]) updated.hooks[event] = [];
     const entry = {
       hooks: [{ type: "command", command: fragment.command }]
     };
     if (fragment.matcher) entry.matcher = fragment.matcher;
     updated.hooks[event] = [...updated.hooks[event] ?? [], entry];
-    addedIds.push(fragment.id);
-    addedCommands.push(fragment.command);
+    if (!existing.includes(fragment.id)) addedIds.push(fragment.id);
+    if (!existingCommands.includes(fragment.command)) addedCommands.push(fragment.command);
   }
   updated._haus = {
     hooks: [...existing, ...addedIds],
@@ -703,6 +716,27 @@ function catalogItemContentPath(contentRoot, item) {
 import path7 from "path";
 import fg2 from "fast-glob";
 import fs4 from "fs-extra";
+
+// src/claude/managed-template.ts
+function normaliseLF(content2) {
+  return content2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+var SCHEMA_VERSION = 1;
+function parseHausManagedHeader(line2) {
+  const match = line2.match(/<!-- HAUS-MANAGED id=([\w.:-]+)/);
+  if (!match) return null;
+  const vMatch = line2.match(/\bv=(\d+)/);
+  const sourceMatch = line2.match(/\bsource=([^\s]+)/);
+  const hashMatch = line2.match(/hash=(sha256-[a-f0-9]+)/);
+  return {
+    id: match[1],
+    v: vMatch ? Number(vMatch[1]) : void 0,
+    source: sourceMatch?.[1],
+    hash: hashMatch?.[1]
+  };
+}
+
+// src/update/hash-installed.ts
 var EMPTY_LOCK_PATHS_TOKEN = "haus-lock:empty-paths";
 async function hashInstalledPaths(root, relPaths) {
   if (relPaths.length === 0) {
@@ -716,7 +750,7 @@ async function hashInstalledPaths(root, relPaths) {
     const stat = await fs4.stat(abs);
     if (stat.isFile()) {
       const body = await fs4.readFile(abs, "utf8");
-      fileDigests.push({ rel, digest: hashText(body) });
+      fileDigests.push({ rel, digest: hashText(normaliseLF(body)) });
       continue;
     }
     if (!stat.isDirectory()) continue;
@@ -725,7 +759,7 @@ async function hashInstalledPaths(root, relPaths) {
       const relFile = path7.join(rel, sub).replace(/\\/g, "/");
       const absFile = path7.join(abs, sub);
       const body = await fs4.readFile(absFile, "utf8");
-      fileDigests.push({ rel: relFile, digest: hashText(body) });
+      fileDigests.push({ rel: relFile, digest: hashText(normaliseLF(body)) });
     }
   }
   if (fileDigests.length === 0) {
@@ -1100,25 +1134,11 @@ async function writeWorkflowConfig(root, dryRun, opts = {}) {
 
 // src/claude/write-workflow.ts
 import fs10 from "fs-extra";
-
-// src/claude/managed-template.ts
-function normaliseLF(content2) {
-  return content2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function parseHausManagedHeader(line2) {
-  const match = line2.match(/<!-- HAUS-MANAGED id=([\w.:-]+)/);
-  if (!match) return null;
-  const hashMatch = line2.match(/hash=(sha256-[a-f0-9]+)/);
-  return { id: match[1], hash: hashMatch?.[1] };
-}
-
-// src/claude/write-workflow.ts
 var STABLE_ID = "template.workflow";
-var SCHEMA_VERSION = "1";
 function makeWorkflowHeader(pkgVersion, contentHash) {
   return `<!-- HAUS-MANAGED id=${STABLE_ID} v=${SCHEMA_VERSION} source=@haus-tech/haus-workflow@${pkgVersion} hash=${contentHash} -->`;
 }
-async function writeWorkflow(root, pkgVersion, dryRun) {
+async function writeWorkflow(root, pkgVersion, dryRun, force = false) {
   const templateContent = await readWorkflowTemplate({ dryRun });
   if (templateContent === null) {
     warn(
@@ -1144,8 +1164,14 @@ ${templateContent}`;
       warn(`${printable}: HAUS-MANAGED id mismatch (expected ${STABLE_ID}) \u2014 skipping`);
       return null;
     }
+    if (parsed.v !== void 0 && parsed.v > SCHEMA_VERSION) {
+      warn(
+        `${printable}: written by a newer haus (template v${parsed.v}) \u2014 upgrade the CLI to manage it`
+      );
+      return null;
+    }
     const existingContent = existing.slice(firstLine.length + 1);
-    if (parsed.hash && hashText(normaliseLF(existingContent)) !== parsed.hash) {
+    if (parsed.hash && hashText(normaliseLF(existingContent)) !== parsed.hash && !force) {
       warn(`${printable}: content modified by user \u2014 skipping. Use --force to overwrite.`);
       return null;
     }
@@ -1191,7 +1217,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds, opts = {}) {
     claudePath(root, "commands", "haus-review.md")
   ];
   const rootClaudeMdPath = await writeRootClaudeMd(root, dryRun);
-  const workflowPath = await writeWorkflow(root, hausVersion2, dryRun);
+  const workflowPath = await writeWorkflow(root, hausVersion2, dryRun, opts.force);
   const workflowConfigPath = await writeWorkflowConfig(root, dryRun, {
     refill: opts.refillConfig
   });
@@ -1417,7 +1443,8 @@ async function runApply(options) {
     }
   }
   const files = await writeClaudeFiles(root, isDryRun, selectedIds, {
-    refillConfig: options.refillConfig
+    refillConfig: options.refillConfig,
+    force: options.force
   });
   if (isDryRun) {
     log(`Dry-run complete \u2014 ${files.length} file(s) planned, none written. Run --write to apply.`);
@@ -2796,35 +2823,45 @@ async function runDoctor(options) {
       "haus apply --write"
     );
   } else {
-    const workflowContent = await readText(workflowPath);
-    const firstLine = workflowContent?.split("\n")[0] ?? "";
+    const workflowContent = await readText(workflowPath) ?? "";
+    const firstLine = workflowContent.split("\n")[0] ?? "";
     if (!firstLine.includes("HAUS-MANAGED")) {
       ok("- .haus-workflow/WORKFLOW.md: OK (user-owned)");
     } else {
       const storedHashMatch = firstLine.match(/hash=(sha256-[a-f0-9]+)/);
-      const cachePath = path20.join(getCacheDir(), "templates/agentic-workflow-standard.md");
-      const bundledPath = path20.join(
-        packageRoot(),
-        "library",
-        "global",
-        "templates",
-        "agentic-workflow-standard.md"
-      );
-      const templatePath = await fs14.pathExists(cachePath) ? cachePath : bundledPath;
-      const templateContent = await readText(templatePath);
-      if (storedHashMatch && templateContent) {
-        const currentHash = hashText(normaliseLF(templateContent));
-        if (storedHashMatch[1] !== currentHash) {
-          flag(
-            "- .haus-workflow/WORKFLOW.md: stale (template updated \u2014 run `haus apply --write`)",
-            "The workflow standard is out of date",
-            "haus apply --write"
-          );
+      const bodyContent = workflowContent.slice(firstLine.length + 1);
+      const onDiskBodyHash = hashText(normaliseLF(bodyContent));
+      if (storedHashMatch && onDiskBodyHash !== storedHashMatch[1]) {
+        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"
+        );
+      } else {
+        const cachePath = path20.join(getCacheDir(), "templates/agentic-workflow-standard.md");
+        const bundledPath = path20.join(
+          packageRoot(),
+          "library",
+          "global",
+          "templates",
+          "agentic-workflow-standard.md"
+        );
+        const templatePath = await fs14.pathExists(cachePath) ? cachePath : bundledPath;
+        const templateContent = await readText(templatePath);
+        if (storedHashMatch && templateContent) {
+          const currentHash = hashText(normaliseLF(templateContent));
+          if (storedHashMatch[1] !== currentHash) {
+            flag(
+              "- .haus-workflow/WORKFLOW.md: stale (template updated \u2014 run `haus apply --write`)",
+              "The workflow standard is out of date",
+              "haus apply --write"
+            );
+          } else {
+            ok("- .haus-workflow/WORKFLOW.md: OK");
+          }
         } else {
           ok("- .haus-workflow/WORKFLOW.md: OK");
         }
-      } else {
-        ok("- .haus-workflow/WORKFLOW.md: OK");
       }
     }
   }
@@ -3036,7 +3073,7 @@ async function confirm(question) {
 async function readChangedFiles(root) {
   if (process.env.HAUS_DISABLE_GIT_SIGNALS === "1") return [];
   try {
-    const result = await runGit(["diff", "--name-only"], { cwd: root });
+    const result = await runGit(["diff", "--name-only"], { cwd: root, timeout: 3e3 });
     if (result.exitCode !== 0) {
       return [];
     }
@@ -5090,7 +5127,7 @@ program.command("apply").option("--dry-run").option("--write").option("--select"
 ).option(
   "--refill-config",
   "Fill still-blank fields in an existing workflow-config.md without touching edited ones"
-).action(runApply);
+).option("--force", "Overwrite user-modified managed workflow files").action(runApply);
 program.command("undo").option("-y, --yes", "Skip confirmation").action(runUndo);
 program.command("explain-recommendation").option("--json").action(runExplainRecommendation);
 program.command("context").option("--task <task>").option("--from-hook").option("--json").option("--verbose").action(runContext);

package/library/global/commands/haus-clone.md

@@ -2,6 +2,8 @@ Clone repositories for this project. Per-repo setup (install, Docker, `.env`) is
 
 Cloning a single repo is always `haus clone <url> [dir]`. This command picks _which_ repos to clone and runs that primitive for each. There are two modes, chosen by whether a name was given.
 
+**Always ask before cloning — never assume.** The user may already have the repos on disk. Do not start cloning until they have confirmed. A missing `repos.local.json` does **not** mean they want a fresh clone; it just means nothing is recorded yet — you must still ask.
+
 ## Mode A — a project name was given (`project:clone <name>`)
 
 Find one repo by name on GitHub and clone it. Does **not** require a workspace or `repos.manifest.json`.
@@ -13,9 +15,9 @@ Find one repo by name on GitHub and clone it. Does **not** require a workspace o
    If that returns nothing, retry **without** `--owner` (a broader, all-of-GitHub search) and tell the user you widened it.
 4. Decide from the results:
    - **0 matches** — tell the user nothing matched `<name>`; offer to try a different name or broaden. Stop.
-   - **1 match** — show `fullName` + description and confirm "Clone this one?" before proceeding.
+   - **1 match** — show `fullName` + description and ask the user to confirm before cloning.
    - **2+ matches** — use `AskUserQuestion` to let the user pick which repo (list each `fullName` with its description; private repos noted). Include a final option like "None of these — search again / broaden" so they can refine.
-5. Clone the chosen repo with `haus clone <url> [dir]`, using the `url` from the search result. Default target is a folder named after the repo under the current directory; confirm where it will land before running. Quote the exact command first.
+5. Once the user has confirmed both the repo and where it should land, clone it with `haus clone <url> [dir]` using the `url` from the search result (default target is a folder named after the repo under the current directory). Quote the exact command first.
 6. Report the result (cloned / skipped if already present / failed). Remind the user that installing dependencies and configuring the repo is still a manual step for now.
 
 ## Mode B — no name was given (`project:clone`)
@@ -24,9 +26,11 @@ Clone a whole **workspace** from its manifest. Workspace-only (a `repos.manifest
 
 1. Confirm `repos.manifest.json` exists at the workspace root. If not, tell the user this mode is for multi-repo workspaces (or they can pass a `<name>` to clone a single repo) and stop.
 2. Read `repos.manifest.json`. Each entry has an `id`, a `folder`, and a git URL (`repo`). If entries have no `repo` URL, ask the user to add them (or supply the URLs) — `haus clone` needs a URL per repo.
-3. Read `repos.local.json` if present — its `pathOverrides` map (`folder` → absolute path) marks repos the user already has locally.
-4. Ask the user, via `AskUserQuestion`, how to obtain the repos:
+3. Read `repos.local.json` if present — its `pathOverrides` map (`folder` → absolute path) marks repos the user already has locally and does not want re-cloned.
+4. **Always ask first**, via `AskUserQuestion` — never skip this, even when `repos.local.json` is absent or every repo is missing locally:
    - **Clean clone** — clone every manifest repo fresh into its `folder` under the workspace.
-   - **Reuse local** — skip any repo already in `repos.local.json` `pathOverrides`; clone only the rest.
-5. For each repo to clone, run (quoting it first): `haus clone <repo-url> <folder>` from the workspace root. Offer `--dry-run` first if the user wants a preview. If one repo fails, report it and continue to the next.
-6. After the loop, report which repos were cloned, skipped (already present or reused local), and failed. Remind the user that installing dependencies and configuring each repo (`.env`, services) is still a manual step for now.
+   - **I already have some or all of them** — the user has clones elsewhere on disk. Ask where they live, then for each repo found there, record it in `repos.local.json` `pathOverrides` (`folder` → absolute path) so it's reused instead of cloned; clone only the repos that aren't found. (You can match by folder name under the directory they give, confirming each.)
+   - **Cancel** — do nothing.
+5. Show the concrete plan before touching anything: list which repos will be cloned (and into which `folder`) and which will be reused/skipped. Get a final go-ahead.
+6. For each repo to clone, run (quoting it first): `haus clone <repo-url> <folder>` from the workspace root. Offer `--dry-run` first if the user wants a preview. If one repo fails, report it and continue to the next.
+7. After the loop, report which repos were cloned, reused (local), skipped (already present), and failed. Remind the user that installing dependencies and configuring each repo (`.env`, services) is still a manual step for now.

package/library/global/commands/haus-cloneandsetup.md

@@ -0,0 +1,49 @@
+Clone a project's repos **and** set each one up locally — node version, dependencies, env scaffold. This is `project:clone` followed by a per-repo setup pass.
+
+**Always ask before doing work — never assume.** Cloning and setup both run things that take time, hit the network, and need auth; confirm with the user before each phase, and respect repos they already have.
+
+## Step 1 — Clone
+
+Run the full `project:clone` flow first by following `~/.claude/commands/haus-clone.md` end to end — whichever mode applies:
+
+- A **name** was given → it finds and clones that one repo from GitHub.
+- **No name** → it clones the workspace's repos from `repos.manifest.json` (asking clean-clone vs reuse-local first).
+
+When that finishes you have a set of repos on disk (freshly cloned and/or reused-local). Carry that list into Step 2.
+
+## Step 2 — Confirm the setup pass
+
+Before running any setup:
+
+1. List the repos you're about to set up and what each will run (node version select, dependency install, etc.). Get a go-ahead. For repos that were **reused** from an existing local clone, ask whether to (re)run setup there too — they may already be set up.
+2. Check `NODE_AUTH_TOKEN` is exported if any repo depends on private `@`-scoped packages (e.g. `@haus-storefront-*`, `@haus-tech/*`). If it's missing, tell the user to set it first — those installs will fail without it. Let them decide whether to continue or stop.
+
+## Step 3 — Set up each repo
+
+For each repo directory, run its setup **in that directory**, detecting what's needed from the repo's own files — don't assume a stack. Run a repo's steps in a single login shell so the selected node version stays active for the install. A robust pattern:
+
+```
+bash -lc 'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; cd "<repo>" && nvm install && corepack enable && yarn install'
+```
+
+Adjust per repo:
+
+1. **Node version.** If `.nvmrc` (or `engines.node` in `package.json`) is present, select it with `nvm install` (reads `.nvmrc`, installs the version if missing, then switches to it). If the user uses `fnm` instead, `fnm use --install-if-missing`. If neither is available, tell the user the required version and continue on the current node.
+2. **JS dependencies.** Enable the pinned package manager with `corepack enable`, then install based on what's present:
+   - `yarn.lock` or `packageManager: "yarn@…"` → `yarn install`
+   - `pnpm-lock.yaml` → `pnpm install`
+   - `package-lock.json` → `npm install`
+   - no JS manifest → skip
+3. **PHP dependencies.** If `composer.json` is present and `composer` is installed → `composer install`. If composer is missing, note it and skip.
+4. **Env scaffold.** If `.env.example` exists and `.env` does not → copy `.env.example` to `.env` (never overwrite an existing `.env`). Tell the user the real values still need filling.
+
+If a repo's setup fails, report the error and **continue to the next repo** — don't abort the whole run.
+
+## Step 4 — Report
+
+Summarise per repo: node version used, dependency install result, composer (if any), env seeded. Then list what's still manual:
+
+- Fill in each `.env` with real values (cross-repo values must match — see the workspace's environment docs).
+- Start Docker services and dev servers in dependency order — see the workspace's local-development docs.
+
+**Do not** start servers or run `docker compose up` / `yarn dev` — this command only prepares the repos.

package/library/global/skills/haus-workflow/SKILL.md

@@ -21,16 +21,17 @@ The unprefixed verbs (`update`, `catalog`, `install`, `uninstall`) act on **this
 haus install** (`~/.claude`, npm) — they manage the haus tool itself, like `npm install -g`.
 The short legacy aliases still work but the names below are canonical.
 
-| Task name (legacy aliases)                                        | Command                 | Scope   | What it does                                                                                                                |
-| ----------------------------------------------------------------- | ----------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
-| `project:init` (`setup`, `init`)                                  | _Setup procedure below_ | project | First-time setup of an **existing** repo: adds AI skills, commands, workflow + project docs                                 |
-| `project:clone [name]` (`clone`)                                  | _Clone procedure below_ | project | No name: clone a **workspace**'s repos from `repos.manifest.json`. With a `name`: find & clone one repo by name from GitHub |
-| `project:refresh` (`apply`, `refresh`, `claude-md`, `regenerate`) | `haus apply --write`    | project | Re-run setup / refresh `.claude/` context + regenerate root `CLAUDE.md` import block                                        |
-| `project:doctor` (`doctor`, `check`)                              | `haus doctor`           | project | Check for install drift                                                                                                     |
-| `update` (`upgrade`)                                              | `haus update`           | global  | Update npm package + catalog + `~/.claude/` (also refreshes this project)                                                   |
-| `catalog`                                                         | `haus update`           | global  | Fetch latest catalog (same command as update)                                                                               |
-| `install` (`global`)                                              | `haus install`          | global  | Seed `~/.claude/` with haus-owned files                                                                                     |
-| `uninstall`                                                       | `haus uninstall`        | global  | Remove all haus global files from `~/.claude/`                                                                              |
+| Task name (legacy aliases)                                        | Command                         | Scope   | What it does                                                                                                                |
+| ----------------------------------------------------------------- | ------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `project:init` (`setup`, `init`)                                  | _Setup procedure below_         | project | First-time setup of an **existing** repo: adds AI skills, commands, workflow + project docs                                 |
+| `project:clone [name]` (`clone`)                                  | _Clone procedure below_         | project | No name: clone a **workspace**'s repos from `repos.manifest.json`. With a `name`: find & clone one repo by name from GitHub |
+| `project:cloneandsetup [name]` (`cloneandsetup`)                  | _Clone & setup procedure below_ | project | Run `project:clone`, then set up each repo locally (node version, deps, `.env`)                                             |
+| `project:refresh` (`apply`, `refresh`, `claude-md`, `regenerate`) | `haus apply --write`            | project | Re-run setup / refresh `.claude/` context + regenerate root `CLAUDE.md` import block                                        |
+| `project:doctor` (`doctor`, `check`)                              | `haus doctor`                   | project | Check for install drift                                                                                                     |
+| `update` (`upgrade`)                                              | `haus update`                   | global  | Update npm package + catalog + `~/.claude/` (also refreshes this project)                                                   |
+| `catalog`                                                         | `haus update`                   | global  | Fetch latest catalog (same command as update)                                                                               |
+| `install` (`global`)                                              | `haus install`                  | global  | Seed `~/.claude/` with haus-owned files                                                                                     |
+| `uninstall`                                                       | `haus uninstall`                | global  | Remove all haus global files from `~/.claude/`                                                                              |
 
 ## Step 1 — Determine the task
 
@@ -51,6 +52,8 @@ Options:
      (haus update — same command; pulls latest workflow templates and lockfile)
   5. [project] project:clone [name] — clone repos
      (no name: clone a workspace from repos.manifest.json; with a name: find & clone one repo by name from GitHub)
+  6. [project] project:cloneandsetup [name] — clone repos, then set them up
+     (project:clone, then per-repo node version + dependency install + .env scaffold)
 ```
 
 Map the user's selection to the command from the alias table, then continue to Step 2.
@@ -63,6 +66,8 @@ Run the mapped command via Bash. Quote the exact command you are running before
 
 **Exception — `project:clone` (`clone`):** this asks the user a question before running, so it is a short procedure too. Skip to **Clone (`project:clone`)** under Step 3 and follow it.
 
+**Exception — `project:cloneandsetup` (`cloneandsetup`):** clone followed by a per-repo setup pass, with confirmations. Skip to **Clone & setup (`project:cloneandsetup`)** under Step 3 and follow it.
+
 ## Step 3 — Post-run steps
 
 After the command completes, follow the relevant post-run steps below.
@@ -74,7 +79,11 @@ After the command completes, follow the relevant post-run steps below.
 
 ### Clone (`project:clone`)
 
-1. Open and follow `~/.claude/commands/haus-clone.md` — the installed `haus-clone` command. With a `name` argument it finds and clones one matching repo from GitHub; with no argument it clones a workspace's repos from `repos.manifest.json`. Per-repo setup (install, Docker, env) is a separate step that isn't wired yet, so just get the repos in place for now.
+1. Open and follow `~/.claude/commands/haus-clone.md` — the installed `haus-clone` command. With a `name` argument it finds and clones one matching repo from GitHub; with no argument it clones a workspace's repos from `repos.manifest.json`. This task only clones — to also install dependencies, use `project:cloneandsetup`.
+
+### Clone & setup (`project:cloneandsetup`)
+
+1. Open and follow `~/.claude/commands/haus-cloneandsetup.md` — it runs the full `project:clone` flow, then sets up each cloned repo locally: selects the node version (`nvm install` from `.nvmrc`), enables corepack, installs JS/PHP dependencies, and seeds `.env`, confirming before each phase. It does not start servers.
 
 ### After `haus apply --write`
 

package/package.json

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