@haus-tech/haus-workflow 0.10.1 → 0.11.1

package/dist/cli.js

@@ -2,11 +2,11 @@
 
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path27 from "path";
+import path28 from "path";
 import { Command } from "commander";
 
 // src/commands/apply.ts
-import path10 from "path";
+import path11 from "path";
 import checkbox from "@inquirer/checkbox";
 
 // src/catalog/remote-catalog.ts
@@ -158,8 +158,8 @@ async function getCacheManifestAge() {
 }
 
 // src/claude/write-claude-files.ts
-import path9 from "path";
-import fs8 from "fs-extra";
+import path10 from "path";
+import fs9 from "fs-extra";
 
 // src/update/hash-installed.ts
 import path3 from "path";
@@ -512,7 +512,8 @@ import path7 from "path";
 import fs6 from "fs-extra";
 var BLOCK_BEGIN = "<!-- HAUS:BEGIN haus-imports v=1 -->";
 var BLOCK_END = "<!-- HAUS:END haus-imports -->";
-var IMPORT_CONTENT = `@.haus-workflow/haus-way-of-work.md
+var IMPORT_CONTENT = `@.haus-workflow/WORKFLOW.md
+@.haus-workflow/workflow-config.md
 @.haus-workflow/project.md`;
 function buildImportBlock() {
   return `${BLOCK_BEGIN}
@@ -562,20 +563,52 @@ async function writeRootClaudeMd(root, dryRun) {
   return filePath;
 }
 
-// src/claude/write-way-of-work.ts
-import os3 from "os";
+// src/claude/write-workflow-config.ts
 import path8 from "path";
 import fs7 from "fs-extra";
-var STABLE_ID2 = "template.way-of-work";
-var SCHEMA_VERSION2 = "1";
-var TEMPLATE_REL = "library/global/templates/haus-way-of-work.md";
-var CATALOG_CACHE_TEMPLATE = path8.join(
-  os3.homedir(),
-  CATALOG_CACHE_SUBDIR,
-  "templates/haus-way-of-work.md"
-);
-function makeWayOfWorkHeader(pkgVersion, contentHash) {
-  return `<!-- HAUS-MANAGED id=${STABLE_ID2} v=${SCHEMA_VERSION2} source=@haus-tech/haus-workflow@${pkgVersion} hash=${contentHash} -->`;
+function buildWorkflowConfig(ctx) {
+  const pm = ctx.packageManager === "unknown" ? "npm" : ctx.packageManager;
+  const testCmd = pm + " test";
+  const auditCmd = pm + " audit";
+  return "# Project workflow configuration\n\n> Project-specific values for the workflow standard in WORKFLOW.md.\n> Edit freely \u2014 this file is project-owned and will not be overwritten by haus.\n\n## Source-of-truth documents\n- Spec: <!-- fill in path, e.g. docs/SPEC.md -->\n- Design: <!-- fill in path, e.g. docs/DESIGN.md -->\n- UX flows: <!-- fill in path, e.g. docs/UX.md -->\n\n## Commands\n- Test (unit + integration): `" + testCmd + "`\n- Test (E2E): <!-- fill in command -->\n- Type check: <!-- fill in command, e.g. tsc --noEmit -->\n- Lint: <!-- fill in command, e.g. npm run lint -->\n- Lint fix: <!-- fill in command, e.g. npm run lint -- --fix -->\n- Format check: <!-- fill in command, e.g. prettier --check . -->\n- Security audit: `" + auditCmd + "`\n\n## Validation library\n<!-- fill in, e.g. zod, yup, joi -->\n\n## Highest-stakes logic\n<!-- fill in domain areas requiring TDD-only treatment, e.g. payment flows, auth, medical data -->\n\n## Pre-commit tool\n<!-- fill in, e.g. lefthook, husky -->\n";
+}
+async function writeWorkflowConfig(root, dryRun) {
+  const destPath = hausPath(root, "workflow-config.md");
+  const printable = displayPath(root, destPath);
+  if (await fs7.pathExists(destPath)) {
+    if (dryRun) log(printable + ": exists (project-owned, skipping)");
+    return null;
+  }
+  const ctx = await readJson(hausPath(root, "context-map.json")) ?? {
+    mode: "fast",
+    generatedAt: "",
+    root,
+    repoName: path8.basename(root),
+    packageManager: "unknown",
+    repoRoles: [],
+    confidence: 0,
+    detectedStacks: {},
+    dependencies: [],
+    securityRisks: [],
+    crossRepoHints: [],
+    warnings: []
+  };
+  const content = buildWorkflowConfig(ctx);
+  if (dryRun) {
+    log(printable + ": would create");
+    return destPath;
+  }
+  await writeText(destPath, content);
+  return destPath;
+}
+
+// src/claude/write-workflow.ts
+import path9 from "path";
+import fs8 from "fs-extra";
+
+// src/claude/managed-template.ts
+function normaliseLF(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 function parseHausManagedHeader(line) {
   const match = line.match(/<!-- HAUS-MANAGED id=([\w.:-]+)/);
@@ -583,23 +616,32 @@ function parseHausManagedHeader(line) {
   const hashMatch = line.match(/hash=(sha256-[a-f0-9]+)/);
   return { id: match[1], hash: hashMatch?.[1] };
 }
-async function writeWayOfWork(root, pkgVersion, dryRun) {
+
+// src/claude/write-workflow.ts
+var STABLE_ID2 = "template.workflow";
+var SCHEMA_VERSION2 = "1";
+var TEMPLATE_REL = "library/global/templates/agentic-workflow-standard.md";
+var CATALOG_CACHE_TEMPLATE = path9.join(CACHE_DIR, "templates/agentic-workflow-standard.md");
+function makeWorkflowHeader(pkgVersion, contentHash) {
+  return `<!-- HAUS-MANAGED id=${STABLE_ID2} v=${SCHEMA_VERSION2} source=@haus-tech/haus-workflow@${pkgVersion} hash=${contentHash} -->`;
+}
+async function writeWorkflow(root, pkgVersion, dryRun) {
   const cachePath = CATALOG_CACHE_TEMPLATE;
-  const packagePath = path8.join(packageRoot(), TEMPLATE_REL);
-  const templatePath = await fs7.pathExists(cachePath) ? cachePath : packagePath;
-  if (!await fs7.pathExists(templatePath)) {
-    warn(`Way-of-work template not found \u2014 run \`haus update\` to fetch from catalog`);
+  const packagePath = path9.join(packageRoot(), TEMPLATE_REL);
+  const templatePath = await fs8.pathExists(cachePath) ? cachePath : packagePath;
+  if (!await fs8.pathExists(templatePath)) {
+    warn(`Workflow template not found \u2014 run \`haus update\` to fetch from catalog`);
     return null;
   }
-  const templateContent = await fs7.readFile(templatePath, "utf8");
-  const contentHash = hashText(templateContent);
-  const header = makeWayOfWorkHeader(pkgVersion, contentHash);
+  const templateContent = await fs8.readFile(templatePath, "utf8");
+  const contentHash = hashText(normaliseLF(templateContent));
+  const header = makeWorkflowHeader(pkgVersion, contentHash);
   const next = `${header}
 ${templateContent}`;
-  const destPath = hausPath(root, "haus-way-of-work.md");
+  const destPath = hausPath(root, "WORKFLOW.md");
   const printable = displayPath(root, destPath);
-  if (await fs7.pathExists(destPath)) {
-    const existing = await fs7.readFile(destPath, "utf8");
+  if (await fs8.pathExists(destPath)) {
+    const existing = await fs8.readFile(destPath, "utf8");
     const firstLine = existing.split("\n")[0] ?? "";
     const parsed = parseHausManagedHeader(firstLine);
     if (!parsed) {
@@ -611,7 +653,7 @@ ${templateContent}`;
       return null;
     }
     const existingContent = existing.slice(firstLine.length + 1);
-    if (parsed.hash && hashText(existingContent) !== parsed.hash) {
+    if (parsed.hash && hashText(normaliseLF(existingContent)) !== parsed.hash) {
       warn(`${printable}: content modified by user \u2014 skipping. Use --force to overwrite.`);
       return null;
     }
@@ -621,7 +663,7 @@ ${templateContent}`;
     }
   }
   if (dryRun) {
-    const prev = await fs7.pathExists(destPath) ? await fs7.readFile(destPath, "utf8") : "";
+    const prev = await fs8.pathExists(destPath) ? await fs8.readFile(destPath, "utf8") : "";
     if (!prev) {
       log(createUnifiedDiff(printable, "", next));
     } else {
@@ -648,7 +690,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
     estimatedTokenReductionPct: 0
   };
   const pkgRoot = packageRoot();
-  const hausVersion = (await readJson(path9.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
+  const hausVersion = (await readJson(path10.join(pkgRoot, "package.json")))?.version ?? "0.0.0";
   const coreFiles = [
     claudePath(root, "settings.json"),
     claudePath(root, "rules", "haus.md"),
@@ -657,9 +699,15 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
     claudePath(root, "commands", "haus-review.md")
   ];
   const rootClaudeMdPath = await writeRootClaudeMd(root, dryRun);
-  const wayOfWorkPath = await writeWayOfWork(root, hausVersion, dryRun);
+  const workflowPath = await writeWorkflow(root, hausVersion, dryRun);
+  const workflowConfigPath = await writeWorkflowConfig(root, dryRun);
   const projectFactsPath = await writeProjectFacts(root, hausVersion, dryRun);
-  const p6Files = [rootClaudeMdPath, projectFactsPath, ...wayOfWorkPath ? [wayOfWorkPath] : []];
+  const p6Files = [
+    rootClaudeMdPath,
+    projectFactsPath,
+    ...workflowPath ? [workflowPath] : [],
+    ...workflowConfigPath ? [workflowConfigPath] : []
+  ];
   const files = dryRun ? [...coreFiles, ...p6Files] : [
     ...coreFiles,
     ...p6Files,
@@ -670,7 +718,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
   await writeManagedJson(root, claudePath(root, "settings.json"), hookSettings, dryRun);
   if (!dryRun) await assertPostApplySettingsMatchCanonical(root, hookSettings);
   const configPath = hausPath(root, "config.json");
-  if (!await fs8.pathExists(configPath)) {
+  if (!await fs9.pathExists(configPath)) {
     await writeManagedJson(root, configPath, DEFAULT_HOOKS_CONFIG, dryRun);
   }
   await writeManagedText(
@@ -698,12 +746,12 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
     dryRun
   );
   const fixtureManifestPath = process.env["HAUS_FIXTURE_CATALOG"];
-  const manifestPath = fixtureManifestPath ?? path9.join(pkgRoot, "library", "catalog", "manifest.json");
-  const manifestDir = path9.dirname(manifestPath);
+  const manifestPath = fixtureManifestPath ?? path10.join(pkgRoot, "library", "catalog", "manifest.json");
+  const manifestDir = path10.dirname(manifestPath);
   const manifest = await readJson(manifestPath) ?? { items: [] };
   const manifestById = new Map((manifest.items ?? []).map((item) => [item.id, item]));
   const cacheManifest = await readJson(
-    path9.join(CACHE_DIR, "manifest.json")
+    path10.join(CACHE_DIR, "manifest.json")
   );
   const cacheManifestById = new Map((cacheManifest?.items ?? []).map((item) => [item.id, item]));
   const installedPathsByItem = /* @__PURE__ */ new Map();
@@ -725,23 +773,23 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
       }
     }
     const cachedItem = cacheManifestById.get(item.id);
-    const cachePath = cachedItem?.path ? path9.join(CACHE_DIR, cachedItem.path) : null;
-    const sourcePath = cachePath && await fs8.pathExists(cachePath) ? cachePath : path9.join(manifestDir, manifestItem.path);
+    const cachePath = cachedItem?.path ? path10.join(CACHE_DIR, cachedItem.path) : null;
+    const sourcePath = cachePath && await fs9.pathExists(cachePath) ? cachePath : path10.join(manifestDir, manifestItem.path);
     const target = item.type === "agent" ? "agents" : item.type === "template" ? "templates" : "skills";
-    const destination = claudePath(root, target, path9.basename(sourcePath));
-    if (await fs8.pathExists(sourcePath)) {
+    const destination = claudePath(root, target, path10.basename(sourcePath));
+    if (await fs9.pathExists(sourcePath)) {
       if (dryRun) {
-        const exists = await fs8.pathExists(destination);
+        const exists = await fs9.pathExists(destination);
         log(
           `${displayPath(root, destination)}: ${exists ? "would overwrite" : "would create"} (${item.id})`
         );
       } else {
-        await fs8.ensureDir(path9.dirname(destination));
-        await fs8.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
+        await fs9.ensureDir(path10.dirname(destination));
+        await fs9.copy(sourcePath, destination, { overwrite: true, errorOnExist: false });
       }
       files.push(destination);
       const current = installedPathsByItem.get(item.id) ?? [];
-      installedPathsByItem.set(item.id, [...current, path9.relative(root, destination)]);
+      installedPathsByItem.set(item.id, [...current, path10.relative(root, destination)]);
       installedIds.add(item.id);
     } else {
       warn(
@@ -792,7 +840,7 @@ async function writeClaudeFiles(root, dryRun, selectedIds) {
   return [...new Set(files)];
 }
 async function writeManagedText(root, filePath, nextText, dryRun) {
-  const prev = await fs8.pathExists(filePath) ? await fs8.readFile(filePath, "utf8") : "";
+  const prev = await fs9.pathExists(filePath) ? await fs9.readFile(filePath, "utf8") : "";
   const printable = displayPath(root, filePath);
   if (dryRun) {
     if (!prev) {
@@ -819,7 +867,7 @@ async function writeManagedJson(root, filePath, value, dryRun) {
 
 // src/commands/apply.ts
 async function cacheHasItems() {
-  const data = await readJson(path10.join(CACHE_DIR, "manifest.json"));
+  const data = await readJson(path11.join(CACHE_DIR, "manifest.json"));
   return Array.isArray(data?.items) && data.items.length > 0;
 }
 async function runApply(options) {
@@ -886,9 +934,9 @@ async function runApply(options) {
 }
 
 // src/catalog/load-catalog.ts
-import os4 from "os";
-import path11 from "path";
-var CACHE_MANIFEST = path11.join(os4.homedir(), CATALOG_CACHE_SUBDIR, "manifest.json");
+import os3 from "os";
+import path12 from "path";
+var CACHE_MANIFEST = path12.join(os3.homedir(), CATALOG_CACHE_SUBDIR, "manifest.json");
 async function loadCatalog(root) {
   const envPath = process.env["HAUS_FIXTURE_CATALOG"];
   if (envPath) {
@@ -897,10 +945,10 @@ async function loadCatalog(root) {
   }
   const cacheData = await readJson(CACHE_MANIFEST);
   if (cacheData?.items?.length) return cacheData.items;
-  const localManifest = path11.join(root, "library/catalog/manifest.json");
+  const localManifest = path12.join(root, "library/catalog/manifest.json");
   const localData = await readJson(localManifest);
   if (localData?.items?.length) return localData.items;
-  const packageManifest = path11.join(packageRoot(), "library/catalog/manifest.json");
+  const packageManifest = path12.join(packageRoot(), "library/catalog/manifest.json");
   const data = await readJson(packageManifest);
   return data?.items ?? [];
 }
@@ -940,7 +988,7 @@ async function runCatalogAudit() {
 }
 
 // src/commands/config.ts
-import path12 from "path";
+import path13 from "path";
 var CONFIG_PATH2 = ".haus-workflow/config.json";
 var HOOK_ALIASES = {
   "hook.context": "context",
@@ -954,7 +1002,7 @@ async function runConfig(key, action) {
     );
   }
   const root = process.cwd();
-  const configPath = path12.join(root, CONFIG_PATH2);
+  const configPath = path13.join(root, CONFIG_PATH2);
   const existing = await readJson(configPath);
   const cfg = existing ?? structuredClone(DEFAULT_HOOKS_CONFIG);
   cfg.hooks ??= {};
@@ -1312,7 +1360,7 @@ function computeRuleIntents(rule) {
 
 // src/scanner/scan-project.ts
 import { readFile } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 
 // src/utils/audit-checks.ts
 function isRecord(v) {
@@ -1339,8 +1387,8 @@ function compareVersions(a, b) {
 }
 
 // src/scanner/detect-package-manager.ts
-import path13 from "path";
-import fs9 from "fs-extra";
+import path14 from "path";
+import fs10 from "fs-extra";
 function detectPackageManager(root, packageManagerField) {
   const field = String(packageManagerField ?? "").trim();
   if (field.startsWith("yarn@")) {
@@ -1358,9 +1406,9 @@ function detectPackageManager(root, packageManagerField) {
     if (satisfiesVersion(version, ">=9")) return "npm";
     return "unknown";
   }
-  if (fs9.existsSync(path13.join(root, "yarn.lock"))) return "yarn";
-  if (fs9.existsSync(path13.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs9.existsSync(path13.join(root, "package-lock.json"))) return "npm";
+  if (fs10.existsSync(path14.join(root, "yarn.lock"))) return "yarn";
+  if (fs10.existsSync(path14.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs10.existsSync(path14.join(root, "package-lock.json"))) return "npm";
   return "unknown";
 }
 
@@ -1421,8 +1469,8 @@ function blocked(rel) {
   return SENSITIVE.some((x) => x.test(rel));
 }
 async function scanProject(root, mode = "fast") {
-  const pkg = await readJson(path14.join(root, "package.json"));
-  const composer = await readJson(path14.join(root, "composer.json"));
+  const pkg = await readJson(path15.join(root, "package.json"));
+  const composer = await readJson(path15.join(root, "composer.json"));
   const files = await listFiles(root, SAFE_FILES);
   const safeFiles = files.filter((f) => !blocked(f));
   const deps = dependencySet(pkg, composer);
@@ -1450,7 +1498,7 @@ async function scanProject(root, mode = "fast") {
     mode,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     root,
-    repoName: String(pkg?.name ?? path14.basename(root)),
+    repoName: String(pkg?.name ?? path15.basename(root)),
     packageManager,
     repoRoles: roles,
     confidence: computeConfidence(roles, stacks),
@@ -1467,7 +1515,7 @@ async function scanProject(root, mode = "fast") {
   const scanHashes = Object.fromEntries(
     await Promise.all(
       safeFiles.map(
-        async (f) => [f, hashText(await readFile(path14.join(root, f), "utf8"))]
+        async (f) => [f, hashText(await readFile(path15.join(root, f), "utf8"))]
       )
     )
   );
@@ -1634,7 +1682,7 @@ async function hasNeedle(root, files, needle) {
   );
   for (const rel of candidates.slice(0, 300)) {
     try {
-      const content = await readFile(path14.join(root, rel), "utf8");
+      const content = await readFile(path15.join(root, rel), "utf8");
       if (content.includes(needle)) return true;
     } catch {
       continue;
@@ -1727,8 +1775,8 @@ async function runContext(options) {
 }
 
 // src/commands/doctor.ts
-import path15 from "path";
-import fs10 from "fs-extra";
+import path16 from "path";
+import fs11 from "fs-extra";
 
 // src/update/npm-version.ts
 var NPM_PACKAGE_NAME = "@haus-tech/haus-workflow";
@@ -1798,7 +1846,7 @@ async function runDoctor(options) {
     const enabled = await isHookEnabled(root, key);
     log(`- HOOK ${key}: ${enabled ? "enabled" : "disabled (default)"}`);
   }
-  const rootClaudeMdPath = path15.join(root, "CLAUDE.md");
+  const rootClaudeMdPath = path16.join(root, "CLAUDE.md");
   const rootClaudeMdContent = await readText(rootClaudeMdPath);
   if (!rootClaudeMdContent) {
     warn("- CLAUDE.md: missing (run `haus apply --write` to create)");
@@ -1807,41 +1855,48 @@ async function runDoctor(options) {
   } else {
     log("- CLAUDE.md: import block present");
   }
-  const wayOfWorkPath = hausPath(root, "haus-way-of-work.md");
-  const wayOfWorkExists = await fs10.pathExists(wayOfWorkPath);
-  if (!wayOfWorkExists) {
-    warn("- .haus-workflow/haus-way-of-work.md: missing (run `haus apply --write`)");
+  const workflowPath = hausPath(root, "WORKFLOW.md");
+  const workflowExists = await fs11.pathExists(workflowPath);
+  if (!workflowExists) {
+    warn("- .haus-workflow/WORKFLOW.md: missing (run `haus apply --write`)");
   } else {
-    const wayOfWorkContent = await readText(wayOfWorkPath);
-    const firstLine = wayOfWorkContent?.split("\n")[0] ?? "";
+    const workflowContent = await readText(workflowPath);
+    const firstLine = workflowContent?.split("\n")[0] ?? "";
     if (!firstLine.includes("HAUS-MANAGED")) {
-      warn("- .haus-workflow/haus-way-of-work.md: no HAUS-MANAGED header (user-owned)");
+      log("- .haus-workflow/WORKFLOW.md: OK (user-owned)");
     } else {
       const storedHashMatch = firstLine.match(/hash=(sha256-[a-f0-9]+)/);
-      const templatePath = path15.join(
+      const cachePath = path16.join(CACHE_DIR, "templates/agentic-workflow-standard.md");
+      const bundledPath = path16.join(
         packageRoot(),
         "library",
         "global",
         "templates",
-        "haus-way-of-work.md"
+        "agentic-workflow-standard.md"
       );
+      const templatePath = await fs11.pathExists(cachePath) ? cachePath : bundledPath;
       const templateContent = await readText(templatePath);
       if (storedHashMatch && templateContent) {
-        const currentHash = hashText(templateContent);
+        const currentHash = hashText(normaliseLF(templateContent));
         if (storedHashMatch[1] !== currentHash) {
-          warn(
-            "- .haus-workflow/haus-way-of-work.md: stale (template updated \u2014 run `haus apply --write`)"
-          );
+          warn("- .haus-workflow/WORKFLOW.md: stale (template updated \u2014 run `haus apply --write`)");
         } else {
-          log("- .haus-workflow/haus-way-of-work.md: OK");
+          log("- .haus-workflow/WORKFLOW.md: OK");
         }
       } else {
-        log("- .haus-workflow/haus-way-of-work.md: OK");
+        log("- .haus-workflow/WORKFLOW.md: OK");
       }
     }
   }
+  const workflowConfigPath = hausPath(root, "workflow-config.md");
+  const workflowConfigExists = await fs11.pathExists(workflowConfigPath);
+  if (!workflowConfigExists) {
+    warn("- .haus-workflow/workflow-config.md: missing (run `haus apply --write`)");
+  } else {
+    log("- .haus-workflow/workflow-config.md: OK (project-owned)");
+  }
   const projectMdPath = hausPath(root, "project.md");
-  const projectMdExists = await fs10.pathExists(projectMdPath);
+  const projectMdExists = await fs11.pathExists(projectMdPath);
   if (!projectMdExists) {
     warn("- .haus-workflow/project.md: missing (run `haus apply --write`)");
   } else {
@@ -1864,7 +1919,7 @@ async function runDoctor(options) {
       log(`- CATALOG CACHE: OK (${cacheAgeDays}d old)`);
     }
   }
-  const pkgJson = await readJson(path15.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path16.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -2031,8 +2086,8 @@ async function runGuard(kind, _options) {
 }
 
 // src/commands/init.ts
-import path16 from "path";
-import fs11 from "fs-extra";
+import path17 from "path";
+import fs12 from "fs-extra";
 
 // src/utils/exec.ts
 import { execa } from "execa";
@@ -2575,8 +2630,8 @@ async function runSetupProject(options) {
 // src/commands/init.ts
 async function runInit(options) {
   const root = process.cwd();
-  const hausDir = path16.join(root, ".haus-workflow");
-  const alreadyInit = await fs11.pathExists(hausDir);
+  const hausDir = path17.join(root, ".haus-workflow");
+  const alreadyInit = await fs12.pathExists(hausDir);
   if (alreadyInit) {
     log("Haus AI already initialized in this project.");
     log("Run `haus setup-project` to reconfigure.");
@@ -2588,8 +2643,8 @@ async function runInit(options) {
 
 // src/install/apply.ts
 import crypto2 from "crypto";
-import path19 from "path";
-import fs13 from "fs-extra";
+import path20 from "path";
+import fs14 from "fs-extra";
 
 // src/install/header.ts
 var MD_PREFIX = "<!-- HAUS-MANAGED";
@@ -2622,14 +2677,14 @@ ${content}`;
 }
 
 // src/install/manifest.ts
-import os5 from "os";
-import path17 from "path";
+import os4 from "os";
+import path18 from "path";
 var MANIFEST_SCHEMA = "haus-install-manifest/1";
 function globalClaudeDir() {
-  return path17.join(os5.homedir(), ".claude");
+  return path18.join(os4.homedir(), ".claude");
 }
 function hausManifestPath() {
-  return path17.join(globalClaudeDir(), "haus", "install-manifest.json");
+  return path18.join(globalClaudeDir(), "haus", "install-manifest.json");
 }
 async function readManifest() {
   return readJson(hausManifestPath());
@@ -2648,10 +2703,10 @@ function buildManifest(source, files, hooks) {
 }
 
 // src/install/settings-merge.ts
-import path18 from "path";
-import fs12 from "fs-extra";
+import path19 from "path";
+import fs13 from "fs-extra";
 function settingsJsonPath() {
-  return path18.join(globalClaudeDir(), "settings.json");
+  return path19.join(globalClaudeDir(), "settings.json");
 }
 async function readSettings() {
   const parsed = await readJson(settingsJsonPath());
@@ -2707,7 +2762,7 @@ function stripHausHooks(settings) {
 async function loadHooksFragment(fragmentPath) {
   let raw;
   try {
-    raw = await fs12.readJson(fragmentPath);
+    raw = await fs13.readJson(fragmentPath);
   } catch {
     return [];
   }
@@ -2722,40 +2777,40 @@ function hashContent(content) {
 }
 function sourceVersion() {
   try {
-    const pkgPath = path19.join(packageRoot(), "package.json");
-    const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path20.join(packageRoot(), "package.json");
+    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf8"));
     return `${pkg.name ?? "haus"}@${pkg.version ?? "0.0.0"}`;
   } catch {
     return "haus@0.0.0";
   }
 }
 function globalSrcDir() {
-  return path19.join(packageRoot(), "library", "global");
+  return path20.join(packageRoot(), "library", "global");
 }
 function collectSourceFiles(srcDir, claudeDir) {
   const entries = [];
-  const skillsDir = path19.join(srcDir, "skills");
-  if (fs13.pathExistsSync(skillsDir)) {
-    for (const skillName of fs13.readdirSync(skillsDir)) {
-      const skillFile = path19.join(skillsDir, skillName, "SKILL.md");
-      if (fs13.pathExistsSync(skillFile)) {
+  const skillsDir = path20.join(srcDir, "skills");
+  if (fs14.pathExistsSync(skillsDir)) {
+    for (const skillName of fs14.readdirSync(skillsDir)) {
+      const skillFile = path20.join(skillsDir, skillName, "SKILL.md");
+      if (fs14.pathExistsSync(skillFile)) {
         entries.push({
           stableId: `skill.${skillName}`,
-          srcRelPath: path19.join("library", "global", "skills", skillName, "SKILL.md"),
-          destPath: path19.join(claudeDir, "skills", skillName, "SKILL.md")
+          srcRelPath: path20.join("library", "global", "skills", skillName, "SKILL.md"),
+          destPath: path20.join(claudeDir, "skills", skillName, "SKILL.md")
         });
       }
     }
   }
-  const agentsDir = path19.join(srcDir, "agents");
-  if (fs13.pathExistsSync(agentsDir)) {
-    for (const agentFile of fs13.readdirSync(agentsDir)) {
+  const agentsDir = path20.join(srcDir, "agents");
+  if (fs14.pathExistsSync(agentsDir)) {
+    for (const agentFile of fs14.readdirSync(agentsDir)) {
       if (!agentFile.endsWith(".md")) continue;
       const agentName = agentFile.replace(/\.md$/, "");
       entries.push({
         stableId: `agent.${agentName}`,
-        srcRelPath: path19.join("library", "global", "agents", agentFile),
-        destPath: path19.join(claudeDir, "agents", agentFile)
+        srcRelPath: path20.join("library", "global", "agents", agentFile),
+        destPath: path20.join(claudeDir, "agents", agentFile)
       });
     }
   }
@@ -2779,7 +2834,7 @@ async function applyInstall(options = {}) {
   };
   const manifestFiles = [];
   for (const entry of sourceFiles) {
-    const srcPath = path19.join(packageRoot(), entry.srcRelPath);
+    const srcPath = path20.join(packageRoot(), entry.srcRelPath);
     const rawContent = await readText(srcPath);
     if (rawContent === void 0) {
       warn(`Source file not found: ${entry.srcRelPath}`);
@@ -2799,7 +2854,7 @@ async function applyInstall(options = {}) {
       }
       continue;
     }
-    const destExists = fs13.pathExistsSync(entry.destPath);
+    const destExists = fs14.pathExistsSync(entry.destPath);
     if (destExists) {
       const currentContent = await readText(entry.destPath);
       if (currentContent !== void 0) {
@@ -2835,7 +2890,7 @@ async function applyInstall(options = {}) {
       schemaVersion: SCHEMA_VERSION3
     });
   }
-  const fragmentPath = path19.join(srcDir, "settings-fragments", "hooks.json");
+  const fragmentPath = path20.join(srcDir, "settings-fragments", "hooks.json");
   const fragments = await loadHooksFragment(fragmentPath);
   const settings = await readSettings();
   const { settings: mergedSettings, addedIds } = mergeHooks(settings, fragments);
@@ -2844,13 +2899,13 @@ async function applyInstall(options = {}) {
     const currentDestPaths = new Set(sourceFiles.map((f) => f.destPath));
     for (const entry of existingManifest.files) {
       if (currentDestPaths.has(entry.destPath)) continue;
-      if (!fs13.pathExistsSync(entry.destPath)) continue;
+      if (!fs14.pathExistsSync(entry.destPath)) continue;
       const content = await readText(entry.destPath);
       if (!content) continue;
       const hasHeader = parseMarkdownHeader(content) !== void 0;
       const currentHash = hashContent(content);
       if (hasHeader && currentHash === entry.hash) {
-        if (!dryRun) await fs13.remove(entry.destPath);
+        if (!dryRun) await fs14.remove(entry.destPath);
         result.deleted.push(entry.destPath);
       } else {
         warn(`Orphaned file ${entry.destPath} was user-modified \u2014 leaving in place`);
@@ -3033,20 +3088,20 @@ async function runScan(options) {
 }
 
 // src/commands/undo.ts
-import path20 from "path";
-import fs14 from "fs-extra";
+import path21 from "path";
+import fs15 from "fs-extra";
 var CLAUDE_DIR = ".claude";
 async function runUndo(options) {
   const root = process.cwd();
-  const targets = [path20.join(root, CLAUDE_DIR), path20.join(root, HAUS_DIR)];
-  const existing = targets.filter((p) => fs14.existsSync(p));
+  const targets = [path21.join(root, CLAUDE_DIR), path21.join(root, HAUS_DIR)];
+  const existing = targets.filter((p) => fs15.existsSync(p));
   if (existing.length === 0) {
     log("Nothing to remove: no .claude/ or .haus-workflow/ in this directory.");
     return;
   }
   if (!options.yes) {
     const ok = await confirm(
-      `Remove ${existing.map((p) => path20.relative(root, p)).join(" and ")}? This cannot be undone.`
+      `Remove ${existing.map((p) => path21.relative(root, p)).join(" and ")}? This cannot be undone.`
     );
     if (!ok) {
       log("Cancelled.");
@@ -3054,15 +3109,15 @@ async function runUndo(options) {
     }
   }
   for (const p of existing) {
-    await fs14.remove(p);
-    log(`Removed ${path20.relative(root, p)}`);
+    await fs15.remove(p);
+    log(`Removed ${path21.relative(root, p)}`);
   }
 }
 
 // src/install/uninstall.ts
 import crypto3 from "crypto";
-import path21 from "path";
-import fs15 from "fs-extra";
+import path22 from "path";
+import fs16 from "fs-extra";
 async function runUninstall(options = {}) {
   const { force = false } = options;
   const manifest = await readManifest();
@@ -3072,7 +3127,7 @@ async function runUninstall(options = {}) {
     return result;
   }
   for (const entry of manifest.files) {
-    const exists = fs15.pathExistsSync(entry.destPath);
+    const exists = fs16.pathExistsSync(entry.destPath);
     if (!exists) continue;
     const content = await readText(entry.destPath);
     if (content === void 0) continue;
@@ -3090,22 +3145,22 @@ async function runUninstall(options = {}) {
       result.skipped.push(entry.destPath);
       continue;
     }
-    await fs15.remove(entry.destPath);
-    await pruneEmptyDir(path21.dirname(entry.destPath));
+    await fs16.remove(entry.destPath);
+    await pruneEmptyDir(path22.dirname(entry.destPath));
     result.deleted.push(entry.destPath);
   }
   const settings = await readSettings();
   const stripped = stripHausHooks(settings);
   await writeSettings(stripped);
   result.hooksStripped = true;
-  const hausDir = path21.join(globalClaudeDir(), "haus");
+  const hausDir = path22.join(globalClaudeDir(), "haus");
   const manifestPath = hausManifestPath();
-  if (fs15.pathExistsSync(manifestPath)) {
-    await fs15.remove(manifestPath);
+  if (fs16.pathExistsSync(manifestPath)) {
+    await fs16.remove(manifestPath);
   }
-  if (fs15.pathExistsSync(hausDir)) {
-    const remaining = await fs15.readdir(hausDir);
-    if (remaining.length === 0) await fs15.remove(hausDir);
+  if (fs16.pathExistsSync(hausDir)) {
+    const remaining = await fs16.readdir(hausDir);
+    if (remaining.length === 0) await fs16.remove(hausDir);
   }
   return result;
 }
@@ -3124,8 +3179,8 @@ function printUninstallResult(result) {
 }
 async function pruneEmptyDir(dir) {
   try {
-    const entries = await fs15.readdir(dir);
-    if (entries.length === 0) await fs15.remove(dir);
+    const entries = await fs16.readdir(dir);
+    if (entries.length === 0) await fs16.remove(dir);
   } catch {
   }
 }
@@ -3143,7 +3198,7 @@ async function runUninstallCommand(options) {
 }
 
 // src/commands/update.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/update/diff-generated-files.ts
 function diffGeneratedFiles() {
@@ -3170,7 +3225,7 @@ function summarizeLockDiff(before, after) {
 
 // src/update/lockfile.ts
 import { mkdir, readFile as readFile2, copyFile } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 async function checkLock(root) {
   const lock = await readJson(hausPath(root, "haus.lock.json")) ?? [];
   const hasValidVersions = lock.every(
@@ -3191,7 +3246,7 @@ async function applyLock(root) {
   try {
     const backupDir = hausPath(root, "backups");
     await mkdir(backupDir, { recursive: true });
-    await copyFile(lockPath, path22.join(backupDir, `haus.lock.${Date.now()}.json`));
+    await copyFile(lockPath, path23.join(backupDir, `haus.lock.${Date.now()}.json`));
   } catch {
   }
   const enriched = await Promise.all(
@@ -3213,7 +3268,7 @@ function diffLock(before, after) {
 }
 async function hasLocalOverrides(root) {
   try {
-    await readFile2(path22.join(root, ".claude", "settings.json"), "utf8");
+    await readFile2(path23.join(root, ".claude", "settings.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -3225,7 +3280,7 @@ var NPM_PACKAGE_NAME2 = "@haus-tech/haus-workflow";
 async function runUpdate(options) {
   const root = process.cwd();
   if (options.check) {
-    const pkgJson2 = await readJson(path23.join(packageRoot(), "package.json"));
+    const pkgJson2 = await readJson(path24.join(packageRoot(), "package.json"));
     const currentVersion2 = pkgJson2?.version ?? "0.0.0";
     const [status, npmVersion, latestCatalogTag] = await Promise.all([
       checkLock(root),
@@ -3252,7 +3307,7 @@ async function runUpdate(options) {
     if (!status.ok) process.exitCode = 1;
     return;
   }
-  const pkgJson = await readJson(path23.join(packageRoot(), "package.json"));
+  const pkgJson = await readJson(path24.join(packageRoot(), "package.json"));
   const currentVersion = pkgJson?.version ?? "0.0.0";
   const npmStatus = await fetchNpmVersionStatus(currentVersion);
   if (npmStatus.updateAvailable && npmStatus.latest !== null) {
@@ -3282,14 +3337,14 @@ async function runUpdate(options) {
 }
 
 // src/commands/validate-catalog.ts
-import fs16 from "fs";
-import path25 from "path";
+import fs17 from "fs";
+import path26 from "path";
 
 // src/catalog/allowed-stacks.ts
-import path24 from "path";
+import path25 from "path";
 async function readAllowedStacks(root) {
   const data = await readJson(
-    path24.join(root, "library", "catalog", "allowed-stacks.json")
+    path25.join(root, "library", "catalog", "allowed-stacks.json")
   );
   return data?.stacks ?? [];
 }
@@ -3394,23 +3449,23 @@ function auditShippedFiles(manifestDir, items) {
   const failures = [];
   for (const item of items) {
     if (!item.path) continue;
-    const absPath = path25.join(manifestDir, item.path);
+    const absPath = path26.join(manifestDir, item.path);
     if (item.type === "skill") {
-      const skillMd = path25.join(absPath, "SKILL.md");
-      if (!fs16.existsSync(skillMd)) {
-        failures.push(`${item.id}: missing ${path25.relative(manifestDir, skillMd)}`);
+      const skillMd = path26.join(absPath, "SKILL.md");
+      if (!fs17.existsSync(skillMd)) {
+        failures.push(`${item.id}: missing ${path26.relative(manifestDir, skillMd)}`);
         continue;
       }
-      const text = fs16.readFileSync(skillMd, "utf8");
+      const text = fs17.readFileSync(skillMd, "utf8");
       for (const section of REQUIRED_SKILL_SECTIONS) {
         if (!text.includes(section)) failures.push(`${item.id}: SKILL.md missing ${section}`);
       }
     } else if (item.type === "agent") {
-      if (!fs16.existsSync(absPath)) {
+      if (!fs17.existsSync(absPath)) {
         failures.push(`${item.id}: missing agent file ${item.path}`);
         continue;
       }
-      const text = fs16.readFileSync(absPath, "utf8");
+      const text = fs17.readFileSync(absPath, "utf8");
       if (!text.startsWith("---")) failures.push(`${item.id}: agent file missing YAML frontmatter`);
       for (const section of REQUIRED_AGENT_SECTIONS) {
         if (!text.includes(section)) failures.push(`${item.id}: agent file missing ${section}`);
@@ -3421,7 +3476,7 @@ function auditShippedFiles(manifestDir, items) {
           failures.push(`${item.id}: agent file contains disallowed phrase "${phrase}"`);
       }
     } else if (item.type === "template") {
-      if (!fs16.existsSync(absPath)) {
+      if (!fs17.existsSync(absPath)) {
         failures.push(`${item.id}: missing template file ${item.path}`);
       }
     }
@@ -3432,11 +3487,11 @@ function auditMarkdownContent(manifestDir) {
   const failures = [];
   const dirs = ["skills", "agents"];
   for (const dir of dirs) {
-    const abs = path25.join(manifestDir, dir);
-    if (!fs16.existsSync(abs)) continue;
+    const abs = path26.join(manifestDir, dir);
+    if (!fs17.existsSync(abs)) continue;
     walkMd(abs, (file) => {
-      const text = fs16.readFileSync(file, "utf8");
-      const rel = path25.relative(manifestDir, file);
+      const text = fs17.readFileSync(file, "utf8");
+      const rel = path26.relative(manifestDir, file);
       const lines = text.split(/\r?\n/);
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? "";
@@ -3455,8 +3510,8 @@ function auditMarkdownContent(manifestDir) {
   return failures;
 }
 function walkMd(dir, fn) {
-  for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
-    const full = path25.join(dir, entry.name);
+  for (const entry of fs17.readdirSync(dir, { withFileTypes: true })) {
+    const full = path26.join(dir, entry.name);
     if (entry.isDirectory()) walkMd(full, fn);
     else if (entry.name.endsWith(".md")) fn(full);
   }
@@ -3467,8 +3522,8 @@ async function runValidateCatalog(manifestPath) {
     process.exitCode = 1;
     return;
   }
-  const abs = path25.resolve(process.cwd(), manifestPath);
-  const manifestDir = path25.dirname(abs);
+  const abs = path26.resolve(process.cwd(), manifestPath);
+  const manifestDir = path26.dirname(abs);
   const data = await readJson(abs);
   if (!data?.items) {
     error(`Could not read catalog manifest at ${abs}`);
@@ -3507,7 +3562,7 @@ async function runValidateCatalog(manifestPath) {
 }
 
 // src/commands/workspace.ts
-import path26 from "path";
+import path27 from "path";
 import YAML from "yaml";
 async function runWorkspace(action) {
   if (action === "init") {
@@ -3540,7 +3595,7 @@ relationships: []
   const summaries = [];
   const ownership = {};
   for (const repo of repos) {
-    const repoRoot = path26.resolve(process.cwd(), repo.path);
+    const repoRoot = path27.resolve(process.cwd(), repo.path);
     const result = await scanProject(repoRoot, "fast");
     summaries.push({
       name: repo.name,
@@ -3576,7 +3631,7 @@ ${summaries.map(
 // src/cli.ts
 function cliVersion() {
   try {
-    const pkgPath = path27.join(packageRoot(), "package.json");
+    const pkgPath = path28.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -3586,7 +3641,7 @@ function cliVersion() {
 var program = new Command();
 function validateRuntimeNodeVersion() {
   try {
-    const pkgPath = path27.join(packageRoot(), "package.json");
+    const pkgPath = path28.join(packageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     const requiredRange = pkg.engines?.node;
     if (requiredRange && !satisfiesVersion(process.version, requiredRange)) {