@haus-tech/haus-workflow 0.18.2 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.19.0](https://github.com/WeAreHausTech/haus-workflow/compare/v0.18.2...v0.19.0) (2026-06-11)
+
+### Features
+
+- **clone:** implement single repository cloning command and related … ([#89](https://github.com/WeAreHausTech/haus-workflow/issues/89)) ([3ac9883](https://github.com/WeAreHausTech/haus-workflow/commit/3ac98838db79bf69a602f5c3c17cfd6a1a7f924a))
+
 ## [0.18.2](https://github.com/WeAreHausTech/haus-workflow/compare/v0.18.1...v0.18.2) (2026-06-11)
 
 ### Bug Fixes

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "fs";
-import path34 from "path";
+import path35 from "path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
@@ -554,8 +554,8 @@ function buildDenyRules() {
   for (const command of DANGEROUS_COMMANDS) {
     rules.push(`Bash(${command}:*)`);
   }
-  for (const path35 of SENSITIVE_PATHS) {
-    const pattern = SENSITIVE_DIRS.has(path35) ? `${path35}/**` : path35;
+  for (const path36 of SENSITIVE_PATHS) {
+    const pattern = SENSITIVE_DIRS.has(path36) ? `${path36}/**` : path36;
     for (const tool of FILE_TOOLS) {
       rules.push(`${tool}(${pattern})`);
     }
@@ -1643,8 +1643,67 @@ async function runCatalogAudit() {
   log("Catalog audit passed.");
 }
 
-// src/commands/config.ts
+// src/commands/clone.ts
+import { existsSync as existsSync2 } from "fs";
 import path14 from "path";
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function runCommand(command, args = [], options = {}) {
+  try {
+    const result = await execa(command, args, {
+      reject: false,
+      // non-zero exits are returned, not thrown
+      ...options
+    });
+    return {
+      command,
+      args,
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Failed to run command: ${command} ${args.join(" ")} (${message})`);
+  }
+}
+async function runGit(args, options = {}) {
+  return runCommand("git", args, options);
+}
+
+// src/commands/clone.ts
+function repoNameFromUrl(url) {
+  const trimmed = url.trim().replace(/\.git$/, "").replace(/\/+$/, "");
+  const tail = trimmed.split(/[/:]/).pop() ?? "";
+  return tail || "repo";
+}
+async function runClone(url, opts = {}) {
+  if (!url || !url.trim()) {
+    error("A git URL is required: `haus clone <url> [dir]`.");
+    process.exitCode = 1;
+    return;
+  }
+  const target = path14.resolve(opts.dir?.trim() || repoNameFromUrl(url));
+  if (existsSync2(target)) {
+    log(`\u2022 ${path14.basename(target)} already present at ${target} \u2014 skipped`);
+    return;
+  }
+  if (opts.dryRun) {
+    log(`would clone ${url} \u2192 ${target}`);
+    return;
+  }
+  const res = await runGit(["clone", url, target]);
+  if (res.exitCode !== 0) {
+    error(`clone failed for ${url}: ${(res.stderr || res.stdout).trim()}`);
+    process.exitCode = 1;
+    return;
+  }
+  log(`\u2713 cloned ${url} \u2192 ${target}`);
+}
+
+// src/commands/config.ts
+import path15 from "path";
 var CONFIG_PATH2 = ".haus-workflow/config.json";
 var HOOK_ALIASES = {
   "hook.context": "context"
@@ -1657,7 +1716,7 @@ async function runConfig(key, action) {
     );
   }
   const root = process.cwd();
-  const configPath = path14.join(root, CONFIG_PATH2);
+  const configPath = path15.join(root, CONFIG_PATH2);
   const existing = await readJson(configPath);
   const cfg = existing ?? structuredClone(DEFAULT_HOOKS_CONFIG);
   cfg.hooks ??= {};
@@ -2029,7 +2088,7 @@ function selectRules(recommended, task, taskIntents) {
 
 // src/scanner/scan-project.ts
 import { readFile as readFile2 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 
 // src/utils/audit-checks.ts
 function isRecord(v) {
@@ -2056,7 +2115,7 @@ function compareVersions(a, b) {
 }
 
 // src/scanner/detect-package-manager.ts
-import path15 from "path";
+import path16 from "path";
 import fs13 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
@@ -2075,9 +2134,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs13.existsSync(path15.join(root, "yarn.lock"))) return "yarn";
-  if (fs13.existsSync(path15.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs13.existsSync(path15.join(root, "package-lock.json"))) return "npm";
+  if (fs13.existsSync(path16.join(root, "yarn.lock"))) return "yarn";
+  if (fs13.existsSync(path16.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs13.existsSync(path16.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
@@ -2250,7 +2309,7 @@ function runDetection(ctx, rules = STACK_RULES) {
 }
 
 // src/scanner/detection.ts
-import path16 from "path";
+import path17 from "path";
 var UNSUPPORTED_MARKERS = {
   "requirements.txt": "python",
   "pyproject.toml": "python",
@@ -2304,14 +2363,14 @@ function finalizeRoles(registryRoles, deps, files) {
 function collectUnsupportedSignals(files) {
   return [
     ...new Set(
-      files.map((f) => UNSUPPORTED_MARKERS[path16.basename(f)]).filter((s) => Boolean(s))
+      files.map((f) => UNSUPPORTED_MARKERS[path17.basename(f)]).filter((s) => Boolean(s))
     )
   ].sort();
 }
 
 // src/scanner/render.ts
 import { readFile } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 
 // src/scanner/role-labels.ts
 var ROLE_LABELS = {
@@ -2373,7 +2432,7 @@ async function buildContentBlob(root, files) {
   const slice = candidates.slice(0, 300);
   const parts = await mapWithConcurrency(slice, async (rel) => {
     try {
-      return await readFile(path17.join(root, rel), "utf8");
+      return await readFile(path18.join(root, rel), "utf8");
     } catch {
       return "";
     }
@@ -2471,8 +2530,8 @@ var SAFE_FILES = [
   "Gemfile"
 ];
 async function scanProject(root, mode = "fast") {
-  const pkg = await readJson(path18.join(root, "package.json"));
-  const composer = await readJson(path18.join(root, "composer.json"));
+  const pkg = await readJson(path19.join(root, "package.json"));
+  const composer = await readJson(path19.join(root, "composer.json"));
   const files = await listFiles(root, SAFE_FILES);
   const safeFiles = files.filter((f) => !blocked(f));
   const deps = dependencySet(pkg, composer);
@@ -2506,7 +2565,7 @@ async function scanProject(root, mode = "fast") {
     mode,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     root,
-    repoName: String(pkg?.name ?? path18.basename(root)),
+    repoName: String(pkg?.name ?? path19.basename(root)),
     packageManager,
     repoRoles: roles,
     detectedStacks: stacks,
@@ -2524,7 +2583,7 @@ async function scanProject(root, mode = "fast") {
   const scanHashes = Object.fromEntries(
     await mapWithConcurrency(
       safeFiles,
-      async (f) => [f, hashText(await readFile2(path18.join(root, f), "utf8"))]
+      async (f) => [f, hashText(await readFile2(path19.join(root, f), "utf8"))]
     )
   );
   const repoSummary = renderSummary(context);
@@ -2609,7 +2668,7 @@ async function runContext(options) {
 }
 
 // src/commands/doctor.ts
-import path19 from "path";
+import path20 from "path";
 import fs14 from "fs-extra";
 
 // src/update/npm-version.ts
@@ -2690,7 +2749,7 @@ async function runDoctor(options) {
     const enabled = await isHookEnabled(root, key);
     ok(`- HOOK ${key}: ${enabled ? "enabled" : "disabled (default)"}`);
   }
-  const rootClaudeMdPath = path19.join(root, "CLAUDE.md");
+  const rootClaudeMdPath = path20.join(root, "CLAUDE.md");
   const rootClaudeMdContent = await readText(rootClaudeMdPath);
   if (!rootClaudeMdContent) {
     flag(
@@ -2743,8 +2802,8 @@ async function runDoctor(options) {
       ok("- .haus-workflow/WORKFLOW.md: OK (user-owned)");
     } else {
       const storedHashMatch = firstLine.match(/hash=(sha256-[a-f0-9]+)/);
-      const cachePath = path19.join(getCacheDir(), "templates/agentic-workflow-standard.md");
-      const bundledPath = path19.join(
+      const cachePath = path20.join(getCacheDir(), "templates/agentic-workflow-standard.md");
+      const bundledPath = path20.join(
         packageRoot(),
         "library",
         "global",
@@ -2809,7 +2868,7 @@ async function runDoctor(options) {
       ok(`- CATALOG CACHE: OK (${cacheAgeDays}d old)`);
     }
   }
-  const pkgJson = await readJson(path19.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path20.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -2952,7 +3011,7 @@ async function runGuard(kind, _options) {
 }
 
 // src/commands/init.ts
-import path20 from "path";
+import path21 from "path";
 import fs15 from "fs-extra";
 
 // src/utils/prompts.ts
@@ -2973,31 +3032,6 @@ async function confirm(question) {
   return answer === "y" || answer === "yes";
 }
 
-// src/utils/exec.ts
-import { execa } from "execa";
-async function runCommand(command, args = [], options = {}) {
-  try {
-    const result = await execa(command, args, {
-      reject: false,
-      // non-zero exits are returned, not thrown
-      ...options
-    });
-    return {
-      command,
-      args,
-      stdout: String(result.stdout ?? ""),
-      stderr: String(result.stderr ?? ""),
-      exitCode: result.exitCode ?? 0
-    };
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`Failed to run command: ${command} ${args.join(" ")} (${message})`);
-  }
-}
-async function runGit(args, options = {}) {
-  return runCommand("git", args, options);
-}
-
 // src/recommender/git-signal.ts
 async function readChangedFiles(root) {
   if (process.env.HAUS_DISABLE_GIT_SIGNALS === "1") return [];
@@ -3340,7 +3374,7 @@ async function runSetupProject(options) {
 // src/commands/init.ts
 async function runInit(options) {
   const root = process.cwd();
-  const hausDir = path20.join(root, ".haus-workflow");
+  const hausDir = path21.join(root, ".haus-workflow");
   const alreadyInit = await fs15.pathExists(hausDir);
   if (alreadyInit) {
     log("Haus AI already initialized in this project.");
@@ -3353,7 +3387,7 @@ async function runInit(options) {
 
 // src/install/apply.ts
 import crypto2 from "crypto";
-import path21 from "path";
+import path22 from "path";
 import fs16 from "fs-extra";
 
 // src/install/header.ts
@@ -3442,7 +3476,7 @@ function hashContent(content2) {
 }
 function sourceVersion() {
   try {
-    const pkgPath = path21.join(packageRoot(), "package.json");
+    const pkgPath = path22.join(packageRoot(), "package.json");
     const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
@@ -3450,32 +3484,32 @@ function sourceVersion() {
   }
 }
 function globalSrcDir() {
-  return path21.join(packageRoot(), "library", "global");
+  return path22.join(packageRoot(), "library", "global");
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  const skillsDir = path21.join(srcDir, "skills");
+  const skillsDir = path22.join(srcDir, "skills");
   if (fs16.pathExistsSync(skillsDir)) {
     for (const skillName of fs16.readdirSync(skillsDir)) {
-      const skillFile = path21.join(skillsDir, skillName, "SKILL.md");
+      const skillFile = path22.join(skillsDir, skillName, "SKILL.md");
       if (fs16.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path21.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path21.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path22.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path22.join(claudeDir, "skills", skillName, "SKILL.md")
         });
       }
     }
   }
-  const commandsDir = path21.join(srcDir, "commands");
+  const commandsDir = path22.join(srcDir, "commands");
   if (fs16.pathExistsSync(commandsDir)) {
     for (const fileName of fs16.readdirSync(commandsDir)) {
       if (!fileName.endsWith(".md")) continue;
       const commandName = fileName.slice(0, -".md".length);
       entries.push({
         stableId: `command.${commandName}`,
-        srcRelPath: path21.join("library", "global", "commands", fileName),
-        destPath: path21.join(claudeDir, "commands", fileName)
+        srcRelPath: path22.join("library", "global", "commands", fileName),
+        destPath: path22.join(claudeDir, "commands", fileName)
       });
     }
   }
@@ -3499,7 +3533,7 @@ async function applyInstall(options = {}) {
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path21.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path22.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -3555,7 +3589,7 @@ async function applyInstall(options = {}) {
       schemaVersion: SCHEMA_VERSION2
     });
   }
-  const fragmentPath = path21.join(srcDir, "settings-fragments", "hooks.json");
+  const fragmentPath = path22.join(srcDir, "settings-fragments", "hooks.json");
   const fragments = await loadHooksFragment(fragmentPath);
   const settings = await readSettings();
   const { settings: hookSettings, addedIds } = mergeHooks(settings, fragments);
@@ -3699,7 +3733,7 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path22 from "path";
+import path23 from "path";
 import fs17 from "fs-extra";
 
 // src/claude/managed-paths.ts
@@ -3726,7 +3760,7 @@ async function collectManagedPaths(root) {
   const lock = await readJson(hausPath(root, "haus.lock.json"));
   for (const row of lock ?? []) {
     for (const rel of row.paths ?? []) {
-      paths.add(path22.resolve(root, rel));
+      paths.add(path23.resolve(root, rel));
     }
   }
   const existing = [];
@@ -3742,7 +3776,7 @@ async function settingsHasHausContent(root) {
   return settings._haus != null;
 }
 async function claudeMdHasHausBlock(root) {
-  const filePath = path22.join(root, "CLAUDE.md");
+  const filePath = path23.join(root, "CLAUDE.md");
   if (!await fs17.pathExists(filePath)) return false;
   const text = await fs17.readFile(filePath, "utf8");
   return text.includes(BLOCK_BEGIN);
@@ -3755,15 +3789,15 @@ async function stripProjectSettings(root) {
   const hasContent = Object.keys(settings).length > 0;
   if (hasContent) {
     await writeProjectSettings(root, settings);
-    log(`Stripped haus rules from ${path22.relative(root, settingsPath)} (user settings preserved).`);
+    log(`Stripped haus rules from ${path23.relative(root, settingsPath)} (user settings preserved).`);
     return true;
   }
   await fs17.remove(settingsPath);
-  log(`Removed ${path22.relative(root, settingsPath)} (no user-owned settings remained).`);
+  log(`Removed ${path23.relative(root, settingsPath)} (no user-owned settings remained).`);
   return true;
 }
 async function stripRootClaudeMd(root) {
-  const filePath = path22.join(root, "CLAUDE.md");
+  const filePath = path23.join(root, "CLAUDE.md");
   if (!await fs17.pathExists(filePath)) return false;
   const prev = await fs17.readFile(filePath, "utf8");
   if (!prev.includes(BLOCK_BEGIN)) return false;
@@ -3791,7 +3825,7 @@ async function runUndo(options) {
     log("Nothing to remove: no haus-managed files found in this directory.");
     return;
   }
-  const relTargets = managed.map((p) => path22.relative(root, p));
+  const relTargets = managed.map((p) => path23.relative(root, p));
   const summaryParts = [...relTargets];
   if (stripSettings) summaryParts.push(".claude/settings.json (haus rules only)");
   if (stripClaudeMd) summaryParts.push("CLAUDE.md (haus import block only)");
@@ -3809,7 +3843,7 @@ User-owned .claude/ files will be preserved.`
   for (const abs of managed) {
     if (!await fs17.pathExists(abs)) continue;
     await fs17.remove(abs);
-    log(`Removed ${path22.relative(root, abs)}`);
+    log(`Removed ${path23.relative(root, abs)}`);
   }
   if (stripSettings) await stripProjectSettings(root);
   if (stripClaudeMd) await stripRootClaudeMd(root);
@@ -3820,7 +3854,7 @@ User-owned .claude/ files will be preserved.`
 
 // src/install/uninstall.ts
 import crypto3 from "crypto";
-import path23 from "path";
+import path24 from "path";
 import fs18 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
@@ -3850,14 +3884,14 @@ async function runUninstall(options = {}) {
       continue;
     }
     await fs18.remove(entry.destPath);
-    await pruneEmptyDir(path23.dirname(entry.destPath));
+    await pruneEmptyDir(path24.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
   const settings = await readSettings();
   const stripped = stripHausHooks(stripHausAllow(stripHausDeny(settings)));
   await writeSettings(stripped);
   result.hooksStripped = true;
-  const hausDir = path23.join(globalClaudeDir(), "haus");
+  const hausDir = path24.join(globalClaudeDir(), "haus");
   const manifestPath2 = hausManifestPath();
   if (fs18.pathExistsSync(manifestPath2)) {
     await fs18.remove(manifestPath2);
@@ -3895,7 +3929,7 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/update.ts
-import path25 from "path";
+import path26 from "path";
 
 // src/update/diff-generated-files.ts
 function diffGeneratedFiles() {
@@ -3922,7 +3956,7 @@ function summarizeLockDiff(before, after) {
 
 // src/update/lockfile.ts
 import { mkdir, readFile as readFile3, copyFile } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 async function checkLock(root) {
   const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
   const hasValidVersions = lock.every(
@@ -3953,7 +3987,7 @@ async function applyLock(root) {
   try {
     const backupDir = hausPath(root, "backups");
     await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path24.join(backupDir, `haus.lock.${Date.now()}.json`));
+    await copyFile(lockPath, path25.join(backupDir, `haus.lock.${Date.now()}.json`));
   } catch {
   }
   const enriched = await Promise.all(
@@ -3975,7 +4009,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile3(path24.join(root, ".claude", "settings.json"), "utf8");
+    await readFile3(path25.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -3987,7 +4021,7 @@ var NPM_PACKAGE_NAME2 = "@haus-tech/haus-workflow";
 async function runUpdate(options) {
   const root = process.cwd();
   if (options.check) {
-    const pkgJson2 = await readJson(path25.join(packageRoot(), "package.json"));
+    const pkgJson2 = await readJson(path26.join(packageRoot(), "package.json"));
     const currentVersion2 = pkgJson2?.version ?? "0.0.0";
     const [status, npmVersion, latestCatalogTag, globalInstallDrift] = await Promise.all([
       checkLock(root),
@@ -4017,7 +4051,7 @@ async function runUpdate(options) {
     if (status.driftCount > 0) process.exitCode = 1;
     return;
   }
-  const pkgJson = await readJson(path25.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path26.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -4095,7 +4129,7 @@ async function detectGlobalInstallDrift() {
 
 // src/commands/validate-catalog.ts
 import fs19 from "fs";
-import path26 from "path";
+import path27 from "path";
 
 // src/catalog/forbidden-content.ts
 var PROSE_FORBIDDEN_TAGS = FORBIDDEN_TAGS.filter((t) => t.toLowerCase() !== "go");
@@ -4227,17 +4261,17 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path) continue;
-    const absPath = path26.join(manifestDir, item.path);
+    const absPath = path27.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path26.join(absPath, "SKILL.md");
+      const skillMd = path27.join(absPath, "SKILL.md");
       if (!fs19.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path26.relative(manifestDir, skillMd)}`);
+        failures.push(`${item.id}: missing ${path27.relative(manifestDir, skillMd)}`);
         continue;
       }
       const text = fs19.readFileSync(skillMd, "utf8");
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: SKILL.md`));
       failures.push(
-        ...auditForbiddenTagsInText(text, `${item.id}: ${path26.relative(manifestDir, skillMd)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path27.relative(manifestDir, skillMd)}`)
       );
     } else if (item.type === "agent") {
       if (!fs19.existsSync(absPath)) {
@@ -4255,7 +4289,7 @@ function auditShippedFiles(manifestDir, items) {
           failures.push(`${item.id}: agent file contains disallowed phrase "${phrase}"`);
       }
       failures.push(
-        ...auditForbiddenTagsInText(text, `${item.id}: ${path26.relative(manifestDir, absPath)}`)
+        ...auditForbiddenTagsInText(text, `${item.id}: ${path27.relative(manifestDir, absPath)}`)
       );
     } else if (item.type === "template") {
       if (!fs19.existsSync(absPath)) {
@@ -4269,7 +4303,7 @@ function auditShippedFiles(manifestDir, items) {
         continue;
       }
       const text = fs19.readFileSync(absPath, "utf8");
-      const rel = path26.relative(manifestDir, absPath);
+      const rel = path27.relative(manifestDir, absPath);
       failures.push(...checkRequiredFrontmatter(text, `${item.id}: ${rel}`));
       failures.push(...auditTemplateContent(manifestDir, absPath, item.id));
     }
@@ -4277,7 +4311,7 @@ function auditShippedFiles(manifestDir, items) {
   return failures;
 }
 function auditTemplateContent(manifestDir, absPath, itemId) {
-  const rel = path26.relative(manifestDir, absPath);
+  const rel = path27.relative(manifestDir, absPath);
   const text = fs19.readFileSync(absPath, "utf8");
   const failures = [];
   const lines = text.split(/\r?\n/);
@@ -4300,11 +4334,11 @@ function auditMarkdownContent(manifestDir) {
   const failures = [];
   const dirs = ["skills", "agents", "templates", "commands"];
   for (const dir of dirs) {
-    const abs = path26.join(manifestDir, dir);
+    const abs = path27.join(manifestDir, dir);
     if (!fs19.existsSync(abs)) continue;
     walkMd(abs, (file) => {
       const text = fs19.readFileSync(file, "utf8");
-      const rel = path26.relative(manifestDir, file);
+      const rel = path27.relative(manifestDir, file);
       const lines = text.split(/\r?\n/);
       for (let i = 0; i < lines.length; i++) {
         const line2 = lines[i] ?? "";
@@ -4324,7 +4358,7 @@ function auditMarkdownContent(manifestDir) {
 }
 function walkMd(dir, fn) {
   for (const entry of fs19.readdirSync(dir, { withFileTypes: true })) {
-    const full = path26.join(dir, entry.name);
+    const full = path27.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -4335,8 +4369,8 @@ async function runValidateCatalog(manifestPath2) {
     process.exitCode = 1;
     return;
   }
-  const abs = path26.resolve(process.cwd(), manifestPath2);
-  const manifestDir = path26.dirname(abs);
+  const abs = path27.resolve(process.cwd(), manifestPath2);
+  const manifestDir = path27.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -4365,8 +4399,8 @@ async function runValidateCatalog(manifestPath2) {
 }
 
 // src/commands/workspace.ts
-import { existsSync as existsSync4, statSync as statSync2 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import path34 from "path";
 
 // src/commands/workspace/aggregate.ts
 async function writeWorkspaceArtifacts(workspaceRoot, repos, relationships = []) {
@@ -4420,7 +4454,7 @@ ${summaries.map(
 }
 
 // src/commands/workspace/config.ts
-import path27 from "path";
+import path28 from "path";
 import YAML from "yaml";
 var WORKSPACE_FILE = "haus.workspace.yaml";
 function parseWorkspaceConfig(text) {
@@ -4443,11 +4477,11 @@ function parseWorkspaceConfig(text) {
   };
 }
 async function readWorkspaceConfig(workspaceRoot) {
-  return parseWorkspaceConfig(await readText(path27.join(workspaceRoot, WORKSPACE_FILE)));
+  return parseWorkspaceConfig(await readText(path28.join(workspaceRoot, WORKSPACE_FILE)));
 }
 
 // src/commands/workspace/discover.ts
-import path28 from "path";
+import path29 from "path";
 import fg3 from "fast-glob";
 import YAML2 from "yaml";
 var DEFAULT_MAX_DEPTH = 3;
@@ -4475,8 +4509,8 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   const gitDirs = /* @__PURE__ */ new Set();
   const manifestDirs = /* @__PURE__ */ new Set();
   for (const match of matches) {
-    const base = path28.posix.basename(match);
-    const dir = path28.posix.dirname(match);
+    const base = path29.posix.basename(match);
+    const dir = path29.posix.dirname(match);
     const owner = dir === "." ? "." : dir;
     if (base === ".git") gitDirs.add(owner);
     else manifestDirs.add(owner);
@@ -4492,9 +4526,9 @@ async function discoverRepos(workspaceRoot, maxDepth = DEFAULT_MAX_DEPTH) {
   }
   repoRoots.sort((a, b) => a.localeCompare(b));
   return mapWithConcurrency(repoRoots, async (relDir) => {
-    const absDir = path28.resolve(workspaceRoot, relDir);
-    const pkg = await readJson(path28.join(absDir, "package.json"));
-    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path28.basename(relDir === "." ? workspaceRoot : absDir);
+    const absDir = path29.resolve(workspaceRoot, relDir);
+    const pkg = await readJson(path29.join(absDir, "package.json"));
+    const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : path29.basename(relDir === "." ? workspaceRoot : absDir);
     let role = "auto";
     try {
       const scan = await scanProject(absDir, "fast");
@@ -4537,7 +4571,7 @@ function renderWorkspaceYaml(config2) {
   });
 }
 async function runDiscover(workspaceRoot, opts = {}) {
-  const yamlPath = path28.join(workspaceRoot, "haus.workspace.yaml");
+  const yamlPath = path29.join(workspaceRoot, "haus.workspace.yaml");
   const existingText = await readText(yamlPath);
   const existing = parseWorkspaceConfig(existingText);
   if (existingText && !existing) {
@@ -4570,19 +4604,19 @@ async function runDiscover(workspaceRoot, opts = {}) {
 }
 
 // src/commands/workspace/doctor.ts
-import { existsSync as existsSync2 } from "fs";
-import path30 from "path";
+import { existsSync as existsSync3 } from "fs";
+import path31 from "path";
 
 // src/commands/workspace/manifest.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path29 from "path";
+import path30 from "path";
 var MANIFEST_FILE = "workspace.manifest.json";
 function manifestPath(workspaceRoot) {
   return hausPath(workspaceRoot, MANIFEST_FILE);
 }
 function hausVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(path29.join(packageRoot(), "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path30.join(packageRoot(), "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -4648,7 +4682,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
   }
   const manifestByName = new Map(manifest.repos.map((r) => [r.name, r]));
   for (const repo of config2.repos) {
-    const repoRoot = path30.resolve(workspaceRoot, repo.path);
+    const repoRoot = path31.resolve(workspaceRoot, repo.path);
     const entry = manifestByName.get(repo.name);
     if (!entry) {
       flag({
@@ -4673,7 +4707,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
         detail: `Set up at haus ${entry.hausVersionAtSetup}, current is ${currentVersion} \u2014 re-run setup.`
       });
     }
-    if (!existsSync2(claudePath(repoRoot))) {
+    if (!existsSync3(claudePath(repoRoot))) {
       flag({
         repo: repo.name,
         kind: "missing-claude",
@@ -4681,7 +4715,7 @@ async function runWorkspaceDoctor(workspaceRoot, opts = {}) {
       });
     }
     const lock = await checkLock(repoRoot);
-    if (!existsSync2(hausPath(repoRoot, "haus.lock.json"))) {
+    if (!existsSync3(hausPath(repoRoot, "haus.lock.json"))) {
       flag({
         repo: repo.name,
         kind: "missing-lock",
@@ -4721,11 +4755,11 @@ function emit(args) {
 }
 
 // src/commands/workspace/setup.ts
-import { existsSync as existsSync3, statSync } from "fs";
-import path32 from "path";
+import { existsSync as existsSync4, statSync } from "fs";
+import path33 from "path";
 
 // src/claude/write-workspace-claude-md.ts
-import path31 from "path";
+import path32 from "path";
 import fs20 from "fs-extra";
 function buildWorkspaceImportBlock(client, members) {
   const memberLines = members.map((m) => `- ${m.name} (${m.path})`);
@@ -4744,7 +4778,7 @@ ${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") : path31.join(workspaceRoot, "CLAUDE.md");
+  const filePath = opts.collision ? hausPath(workspaceRoot, "WORKSPACE.md") : path32.join(workspaceRoot, "CLAUDE.md");
   const prev = await fs20.pathExists(filePath) ? await fs20.readFile(filePath, "utf8") : "";
   const next = opts.collision ? `${block}
 ` : injectHausBlock(prev, block);
@@ -4770,21 +4804,21 @@ async function writeWorkspaceClaudeMd(workspaceRoot, opts) {
 
 // src/commands/workspace/setup.ts
 function resolveWorkspaceRoot(start = process.cwd()) {
-  let dir = path32.resolve(start);
+  let dir = path33.resolve(start);
   for (; ; ) {
-    if (existsSync3(path32.join(dir, WORKSPACE_FILE))) return dir;
-    const parent = path32.dirname(dir);
-    if (parent === dir) return path32.resolve(start);
+    if (existsSync4(path33.join(dir, WORKSPACE_FILE))) return dir;
+    const parent = path33.dirname(dir);
+    if (parent === dir) return path33.resolve(start);
     dir = parent;
   }
 }
 function isRootRepo(workspaceRoot, repoPath) {
-  return path32.resolve(workspaceRoot, repoPath) === path32.resolve(workspaceRoot);
+  return path33.resolve(workspaceRoot, repoPath) === path33.resolve(workspaceRoot);
 }
 async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const mode = options.mode ?? "fast";
   const apply = options.write ?? false;
-  const configText = await readText(path32.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path33.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -4801,11 +4835,11 @@ async function runWorkspaceSetup(workspaceRoot, options = {}) {
   const statuses = [];
   const aggregateInputs = [];
   for (const repo of repos) {
-    const repoRoot = path32.resolve(workspaceRoot, repo.path);
+    const repoRoot = path33.resolve(workspaceRoot, repo.path);
     log(`
 \u2192 ${repo.name} (${repo.path})`);
     try {
-      if (!existsSync3(repoRoot) || !statSync(repoRoot).isDirectory()) {
+      if (!existsSync4(repoRoot) || !statSync(repoRoot).isDirectory()) {
         throw new Error(`Repo path is not a directory: ${repo.path}`);
       }
       const res = await runSetupCore(repoRoot, {
@@ -4859,7 +4893,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 && existsSync3(manifestPath(workspaceRoot))) {
+    if (!prior && existsSync4(manifestPath(workspaceRoot))) {
       warn(
         "Existing workspace.manifest.json is unreadable \u2014 prior per-repo state will not be carried forward."
       );
@@ -4870,7 +4904,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(path32.resolve(workspaceRoot, repo.path));
+        const lock = await checkLock(path33.resolve(workspaceRoot, repo.path));
         manifestRepos.push({
           name: repo.name,
           path: repo.path,
@@ -4950,7 +4984,7 @@ relationships: []
   log("Workspace initialized.");
 }
 async function scanWorkspace(workspaceRoot, opts) {
-  const configText = await readText(path33.join(workspaceRoot, WORKSPACE_FILE));
+  const configText = await readText(path34.join(workspaceRoot, WORKSPACE_FILE));
   if (!configText) {
     error(`Missing ${WORKSPACE_FILE}. Run \`haus workspace discover\` or \`init\` first.`);
     process.exitCode = 1;
@@ -4971,8 +5005,8 @@ async function scanWorkspace(workspaceRoot, opts) {
   }
   const inputs = [];
   for (const repo of config2.repos) {
-    const repoRoot = path33.resolve(workspaceRoot, repo.path);
-    if (!existsSync4(repoRoot) || !statSync2(repoRoot).isDirectory()) {
+    const repoRoot = path34.resolve(workspaceRoot, repo.path);
+    if (!existsSync5(repoRoot) || !statSync2(repoRoot).isDirectory()) {
       throw new Error(`Repo path is not a directory: ${repo.path}`);
     }
     const result = await scanProject(repoRoot, "fast");
@@ -5022,7 +5056,7 @@ async function runWorkspace(action, options = {}) {
 // src/cli.ts
 function cliVersion() {
   try {
-    const pkgPath = path34.join(packageRoot(), "package.json");
+    const pkgPath = path35.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -5032,7 +5066,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path34.join(packageRoot(), "package.json");
+    const pkgPath = path35.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {
@@ -5061,6 +5095,9 @@ 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);
 program.command("init").option("--json").action(runInit);
+program.command("clone").description("Clone a single git repository by URL").argument("<url>", "Git URL to clone").argument("[dir]", "Target directory (default: repo name derived from the URL)").option("--dry-run", "Print what would happen without cloning").action(
+  (url, dir, opts) => runClone(url, { dir, dryRun: opts.dryRun })
+);
 program.command("refresh").action(runRefresh);
 program.command("catalog-audit").action(runCatalogAudit);
 program.command("validate-catalog").argument("[manifest]").action(runValidateCatalog);

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

@@ -0,0 +1,32 @@
+Clone repositories for this project. Per-repo setup (install, Docker, `.env`) is a separate step that isn't wired yet — this command only gets repos onto disk.
+
+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.
+
+## 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`.
+
+1. Make sure GitHub CLI is ready: run `gh auth status`. If not authenticated, tell the user to run `gh auth login` and stop.
+2. Scope the search to repos the user owns or belongs to: get their login with `gh api user -q .login` and their orgs with `gh api user/orgs -q '.[].login'`.
+3. Search by name, passing one `--owner` per login/org from step 2:
+   `gh search repos "<name>" --match name --limit 10 --json fullName,description,url,isPrivate,pushedAt --owner <login> [--owner <org> …]`
+   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.
+   - **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.
+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`)
+
+Clone a whole **workspace** from its manifest. Workspace-only (a `repos.manifest.json` at the repo root); for a lone repo without a manifest, use Mode A with a name instead.
+
+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:
+   - **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.

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

@@ -21,15 +21,16 @@ 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: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: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
 
@@ -48,6 +49,8 @@ Options:
      (haus update — checks npm for new version, fetches catalog, refreshes ~/.claude/)
   4. [global] catalog — fetch catalog updates only
      (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)
 ```
 
 Map the user's selection to the command from the alias table, then continue to Step 2.
@@ -58,6 +61,8 @@ Run the mapped command via Bash. Quote the exact command you are running before
 
 **Exception — `project:init` (`setup` / `init`):** this maps to a multi-step procedure, not a single command. Do not run a bare `haus init`. Skip to **Setup (`project:init`)** under Step 3 and follow it.
 
+**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.
+
 ## Step 3 — Post-run steps
 
 After the command completes, follow the relevant post-run steps below.
@@ -67,6 +72,10 @@ After the command completes, follow the relevant post-run steps below.
 1. Open and follow `~/.claude/commands/haus-setup.md` — the installed `haus-setup` command (in some projects also `.claude/commands/haus-setup.md`). Run every step in order. It detects the stack, asks the guided questions, runs `haus apply --write` (scaffolding, skills, commands, rules, docs skill), writes the **project docs** (`CLAUDE.md` body + `docs/`) and `.haus-workflow/deep-context.json`, runs `haus recommend`, applies the newly-matched helpers, and confirms.
 2. Then fill `.haus-workflow/workflow-config.md` — replace every placeholder (`TODO`, `n/a`, empty): test/lint/typecheck/build commands (check `package.json`), docs paths, validation library, pre-commit tool, highest-stakes logic (ask if unclear). Leave none.
 
+### 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.
+
 ### After `haus apply --write`
 
 Verify that the root `CLAUDE.md` imports all three haus files:

package/package.json

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