@harness-engineering/cli 1.14.0 → 1.15.0

package/dist/{chunk-XKECDXJS.js → chunk-J4RAX7YB.js}

@@ -6,7 +6,7 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-6KTUUFRN.js";
+} from "./chunk-LGYBN7Y6.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
@@ -50,14 +50,14 @@ import {
   handleGetImpact,
   handleOrphanDeletion,
   persistToolingConfig
-} from "./chunk-YZD2MRNQ.js";
+} from "./chunk-NNHDDXYT.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-ZOAWBDWU.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-O5OJVPL6.js";
+} from "./chunk-B2HKP423.js";
 import {
   resolveGlobalSkillsDir,
   resolvePersonasDir,
@@ -127,14 +127,14 @@ import {
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-ABQHQ6I5.js";
+} from "./chunk-Z2OOPXJO.js";
 import {
   Err,
   Ok
 } from "./chunk-ERS5EVUZ.js";
 
 // src/index.ts
-import { Command as Command55 } from "commander";
+import { Command as Command61 } from "commander";
 
 // src/commands/validate.ts
 import { Command } from "commander";
@@ -213,7 +213,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-WNJM6H2D.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-OABMREW4.js");
       const cwd = process.cwd();
       const specsDir = path.join(cwd, "docs", "specs");
       const plansDir = path.join(cwd, "docs", "plans");
@@ -481,10 +481,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path4.resolve(cwd);
   let configData = {};
   try {
-    const fs23 = await import("fs");
+    const fs29 = await import("fs");
     const configPath = path4.join(projectRoot, "harness.config.json");
-    if (fs23.existsSync(configPath)) {
-      const raw = fs23.readFileSync(configPath, "utf-8");
+    if (fs29.existsSync(configPath)) {
+      const raw = fs29.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -570,7 +570,7 @@ function registerBenchCommand(perf) {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-HWXF2C3R.js");
+    const { BenchmarkRunner } = await import("./dist-ALQDD67R.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
@@ -638,7 +638,7 @@ function registerBaselinesCommands(perf) {
   baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-HWXF2C3R.js");
+    const { BenchmarkRunner } = await import("./dist-ALQDD67R.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -671,7 +671,7 @@ function registerReportCommand(perf) {
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-HWXF2C3R.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-ALQDD67R.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -3125,8 +3125,8 @@ function createResetCommand() {
     }
     if (!opts.yes) {
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve29) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve29);
+      const answer = await new Promise((resolve30) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve30);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -3240,11 +3240,302 @@ function createStateCommand() {
   return command;
 }
 
+// src/commands/setup.ts
+import { Command as Command34 } from "commander";
+import * as fs17 from "fs";
+import * as os4 from "os";
+import * as path29 from "path";
+import chalk3 from "chalk";
+
+// src/utils/first-run.ts
+import * as fs16 from "fs";
+import * as os3 from "os";
+import * as path28 from "path";
+var HARNESS_DIR = path28.join(os3.homedir(), ".harness");
+var MARKER_FILE = path28.join(HARNESS_DIR, ".setup-complete");
+function isFirstRun() {
+  return !fs16.existsSync(MARKER_FILE);
+}
+function markSetupComplete() {
+  fs16.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs16.writeFileSync(MARKER_FILE, "", "utf-8");
+}
+function printFirstRunWelcome() {
+  try {
+    if (!isFirstRun()) return;
+    if (process.env.CI) return;
+    if (process.argv.includes("--quiet")) return;
+    process.stderr.write("Welcome to harness! Run `harness setup` to get started.\n");
+  } catch {
+  }
+}
+
+// src/utils/node-version.ts
+import semver2 from "semver";
+var REQUIRED_NODE_VERSION = ">=22.0.0";
+function checkNodeVersion() {
+  return {
+    satisfies: semver2.satisfies(process.version, REQUIRED_NODE_VERSION),
+    current: process.version,
+    required: ">=22"
+  };
+}
+
+// src/commands/setup.ts
+function checkNodeVersion2() {
+  const result = checkNodeVersion();
+  if (result.satisfies) {
+    return { status: "pass", message: `Node.js ${result.current} (requires ${result.required})` };
+  }
+  return { status: "fail", message: `Node.js ${result.current} \u2014 requires ${result.required}` };
+}
+function runSlashCommandGeneration() {
+  try {
+    const results = generateSlashCommands({
+      global: true,
+      platforms: ["claude-code", "gemini-cli"],
+      yes: true,
+      includeGlobal: false,
+      skillsDir: "",
+      dryRun: false
+    });
+    const outputDirs = results.map((r) => r.outputDir).join(", ");
+    return { status: "pass", message: `Generated global slash commands -> ${outputDirs}` };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { status: "fail", message: `Slash command generation failed \u2014 ${msg}` };
+  }
+}
+function detectClient(dirName) {
+  return fs17.existsSync(path29.join(os4.homedir(), dirName));
+}
+function runMcpSetup(cwd) {
+  const results = [];
+  const clients = [
+    { name: "Claude Code", dir: ".claude", client: "claude", configTarget: ".mcp.json" },
+    {
+      name: "Gemini CLI",
+      dir: ".gemini",
+      client: "gemini",
+      configTarget: ".gemini/settings.json"
+    }
+  ];
+  for (const { name, dir, client, configTarget } of clients) {
+    if (!detectClient(dir)) {
+      results.push({
+        status: "warn",
+        message: `${name} not detected \u2014 skipped MCP configuration`
+      });
+      continue;
+    }
+    try {
+      setupMcp(cwd, client);
+      results.push({ status: "pass", message: `Configured MCP for ${name} -> ${configTarget}` });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      results.push({
+        status: "fail",
+        message: `MCP configuration failed for ${name} \u2014 ${msg}`
+      });
+    }
+  }
+  return results;
+}
+function formatStep(result) {
+  const icon = result.status === "pass" ? chalk3.green("\u2713") : result.status === "warn" ? chalk3.yellow("\u26A0") : chalk3.red("\u2717");
+  return `  ${icon} ${result.message}`;
+}
+function runSetup(cwd) {
+  const steps = [];
+  const nodeResult = checkNodeVersion2();
+  steps.push(nodeResult);
+  if (nodeResult.status === "fail") {
+    return { steps, success: false };
+  }
+  const slashResult = runSlashCommandGeneration();
+  steps.push(slashResult);
+  const mcpResults = runMcpSetup(cwd);
+  steps.push(...mcpResults);
+  const success = steps.every((s) => s.status !== "fail");
+  if (success) {
+    markSetupComplete();
+  }
+  return { steps, success };
+}
+function createSetupCommand() {
+  return new Command34("setup").description("Configure harness environment: slash commands, MCP, and more").action(() => {
+    const cwd = process.cwd();
+    console.log("");
+    console.log(`  ${chalk3.bold("harness setup")}`);
+    console.log("");
+    const { steps, success } = runSetup(cwd);
+    for (const step of steps) {
+      console.log(formatStep(step));
+    }
+    console.log("");
+    if (success) {
+      console.log("  Setup complete. Next steps:");
+      console.log("    - Open a project directory and run /harness:initialize-project");
+      console.log("    - Or run harness init --name my-project to scaffold a new one");
+      console.log("    - Run harness doctor anytime to check your environment");
+      console.log("");
+    }
+    process.exit(success ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
+  });
+}
+
+// src/commands/doctor.ts
+import { Command as Command35 } from "commander";
+import * as fs18 from "fs";
+import * as os5 from "os";
+import * as path30 from "path";
+import chalk4 from "chalk";
+function checkNodeVersion3() {
+  const result = checkNodeVersion();
+  if (result.satisfies) {
+    return {
+      name: "node",
+      status: "pass",
+      message: `Node.js ${result.current} (requires ${result.required})`
+    };
+  }
+  return {
+    name: "node",
+    status: "fail",
+    message: `Node.js ${result.current} (requires ${result.required})`,
+    fix: "Install Node.js >= 22: https://nodejs.org/"
+  };
+}
+function countCommandFiles(dir, ext) {
+  try {
+    return fs18.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
+  } catch {
+    return 0;
+  }
+}
+function checkSlashCommands() {
+  const platforms = [
+    {
+      name: "Claude Code",
+      dir: path30.join(os5.homedir(), ".claude", "commands", "harness"),
+      ext: ".md",
+      client: "claude-code"
+    },
+    {
+      name: "Gemini CLI",
+      dir: path30.join(os5.homedir(), ".gemini", "commands", "harness"),
+      ext: ".toml",
+      client: "gemini-cli"
+    }
+  ];
+  return platforms.map(({ name, dir, ext, client }) => {
+    const count = countCommandFiles(dir, ext);
+    if (count > 0) {
+      return {
+        name: `slash-commands-${client}`,
+        status: "pass",
+        message: `Slash commands installed -> ${dir} (${count} commands)`
+      };
+    }
+    return {
+      name: `slash-commands-${client}`,
+      status: "fail",
+      message: `No slash commands found for ${name}`,
+      fix: "Run: harness setup"
+    };
+  });
+}
+function readJsonSafe(filePath) {
+  try {
+    if (!fs18.existsSync(filePath)) return null;
+    return JSON.parse(fs18.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function checkMcpConfig(cwd) {
+  const results = [];
+  const claudeConfigPath = path30.join(cwd, ".mcp.json");
+  const claudeConfig = readJsonSafe(claudeConfigPath);
+  if (claudeConfig?.mcpServers?.["harness"]) {
+    results.push({
+      name: "mcp-claude",
+      status: "pass",
+      message: "MCP configured for Claude Code"
+    });
+  } else {
+    results.push({
+      name: "mcp-claude",
+      status: "fail",
+      message: "MCP not configured for Claude Code",
+      fix: "Run: harness setup-mcp --client claude"
+    });
+  }
+  const geminiConfigPath = path30.join(os5.homedir(), ".gemini", "settings.json");
+  const geminiConfig = readJsonSafe(geminiConfigPath);
+  if (geminiConfig?.mcpServers?.["harness"]) {
+    results.push({
+      name: "mcp-gemini",
+      status: "pass",
+      message: "MCP configured for Gemini CLI"
+    });
+  } else {
+    results.push({
+      name: "mcp-gemini",
+      status: "fail",
+      message: "MCP not configured for Gemini CLI",
+      fix: "Run: harness setup-mcp --client gemini"
+    });
+  }
+  return results;
+}
+function runDoctor(cwd) {
+  const checks = [];
+  checks.push(checkNodeVersion3());
+  checks.push(...checkSlashCommands());
+  checks.push(...checkMcpConfig(cwd));
+  const allPassed = checks.every((c) => c.status === "pass");
+  return { checks, allPassed };
+}
+function formatCheck(check) {
+  const icon = check.status === "pass" ? chalk4.green("\u2713") : chalk4.red("\u2717");
+  let line = `  ${icon} ${check.message}`;
+  if (check.status === "fail" && check.fix) {
+    line += `
+    -> ${check.fix}`;
+  }
+  return line;
+}
+function createDoctorCommand() {
+  return new Command35("doctor").description("Check environment health: Node version, slash commands, MCP configuration").action((_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const useJson = globalOpts.json;
+    const result = runDoctor(cwd);
+    if (useJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("");
+      console.log(`  ${chalk4.bold("harness doctor")}`);
+      console.log("");
+      for (const check of result.checks) {
+        console.log(formatCheck(check));
+      }
+      console.log("");
+      const passed = result.checks.filter((c) => c.status === "pass").length;
+      const total = result.checks.length;
+      console.log(`  ${passed}/${total} checks passed`);
+      console.log("");
+    }
+    process.exit(result.allPassed ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
+  });
+}
+
 // src/commands/ci/index.ts
-import { Command as Command36 } from "commander";
+import { Command as Command38 } from "commander";
 
 // src/commands/ci/check.ts
-import { Command as Command34 } from "commander";
+import { Command as Command36 } from "commander";
 var VALID_CHECKS = [
   "validate",
   "deps",
@@ -3284,7 +3575,7 @@ function parseFailOn(failOn) {
   return "error";
 }
 function createCheckCommand() {
-  return new Command34("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate, arch)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+  return new Command36("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate, arch)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = resolveOutputMode(globalOpts);
     const skip = parseSkip(opts.skip);
@@ -3328,9 +3619,9 @@ function createCheckCommand() {
 }
 
 // src/commands/ci/init.ts
-import { Command as Command35 } from "commander";
-import * as fs16 from "fs";
-import * as path28 from "path";
+import { Command as Command37 } from "commander";
+import * as fs19 from "fs";
+import * as path31 from "path";
 var ALL_CHECKS = [
   "validate",
   "deps",
@@ -3431,12 +3722,12 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs16.existsSync(".github")) return "github";
-  if (fs16.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs19.existsSync(".github")) return "github";
+  if (fs19.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function createInitCommand2() {
-  return new Command35("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
+  return new Command37("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platform = opts.platform ?? detectPlatform() ?? "generic";
     const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
@@ -3448,12 +3739,12 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path28.resolve(filename);
-    const dir = path28.dirname(targetPath);
-    fs16.mkdirSync(dir, { recursive: true });
-    fs16.writeFileSync(targetPath, content);
+    const targetPath = path31.resolve(filename);
+    const dir = path31.dirname(targetPath);
+    fs19.mkdirSync(dir, { recursive: true });
+    fs19.writeFileSync(targetPath, content);
     if (platform === "generic" && process.platform !== "win32") {
-      fs16.chmodSync(targetPath, "755");
+      fs19.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -3466,18 +3757,275 @@ function createInitCommand2() {
 
 // src/commands/ci/index.ts
 function createCICommand() {
-  const command = new Command36("ci").description("CI/CD integration commands");
+  const command = new Command38("ci").description("CI/CD integration commands");
   command.addCommand(createCheckCommand());
   command.addCommand(createInitCommand2());
   return command;
 }
 
+// src/commands/hooks/index.ts
+import { Command as Command42 } from "commander";
+
+// src/commands/hooks/init.ts
+import { Command as Command39 } from "commander";
+import * as fs20 from "fs";
+import * as path32 from "path";
+import { fileURLToPath } from "url";
+
+// src/hooks/profiles.ts
+var HOOK_SCRIPTS = [
+  { name: "block-no-verify", event: "PreToolUse", matcher: "Bash", minProfile: "minimal" },
+  { name: "protect-config", event: "PreToolUse", matcher: "Write|Edit", minProfile: "standard" },
+  { name: "quality-gate", event: "PostToolUse", matcher: "Edit|Write", minProfile: "standard" },
+  { name: "pre-compact-state", event: "PreCompact", matcher: "*", minProfile: "standard" },
+  { name: "cost-tracker", event: "Stop", matcher: "*", minProfile: "strict" }
+];
+var PROFILE_ORDER = ["minimal", "standard", "strict"];
+function hooksForProfile(profile) {
+  const profileIndex = PROFILE_ORDER.indexOf(profile);
+  return HOOK_SCRIPTS.filter((h) => PROFILE_ORDER.indexOf(h.minProfile) <= profileIndex).map(
+    (h) => h.name
+  );
+}
+var PROFILES = {
+  minimal: hooksForProfile("minimal"),
+  standard: hooksForProfile("standard"),
+  strict: hooksForProfile("strict")
+};
+
+// src/commands/hooks/init.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path32.dirname(__filename);
+var VALID_PROFILES = ["minimal", "standard", "strict"];
+function resolveHookSourceDir() {
+  const candidate = path32.resolve(__dirname, "..", "..", "hooks");
+  if (fs20.existsSync(candidate)) {
+    return candidate;
+  }
+  throw new Error(`Cannot locate hook scripts directory. Expected at: ${candidate}`);
+}
+function buildSettingsHooks(profile) {
+  const activeHookNames = PROFILES[profile];
+  const activeScripts = HOOK_SCRIPTS.filter((h) => activeHookNames.includes(h.name));
+  const hooks = {};
+  for (const script of activeScripts) {
+    if (!hooks[script.event]) {
+      hooks[script.event] = [];
+    }
+    hooks[script.event].push({
+      matcher: script.matcher,
+      hooks: [{ type: "command", command: `node .harness/hooks/${script.name}.js` }]
+    });
+  }
+  return hooks;
+}
+function mergeSettings(existing, hooksConfig) {
+  return {
+    ...existing,
+    hooks: hooksConfig
+  };
+}
+function initHooks(options) {
+  const { profile, projectDir } = options;
+  const hooksDestDir = path32.join(projectDir, ".harness", "hooks");
+  fs20.mkdirSync(hooksDestDir, { recursive: true });
+  if (fs20.existsSync(hooksDestDir)) {
+    for (const entry of fs20.readdirSync(hooksDestDir)) {
+      if (entry.endsWith(".js")) {
+        fs20.unlinkSync(path32.join(hooksDestDir, entry));
+      }
+    }
+  }
+  const sourceDir = resolveHookSourceDir();
+  const copiedScripts = [];
+  const activeNames = PROFILES[profile];
+  const activeScripts = HOOK_SCRIPTS.filter((h) => activeNames.includes(h.name));
+  for (const script of activeScripts) {
+    const srcFile = path32.join(sourceDir, `${script.name}.js`);
+    const destFile = path32.join(hooksDestDir, `${script.name}.js`);
+    if (fs20.existsSync(srcFile)) {
+      fs20.copyFileSync(srcFile, destFile);
+      copiedScripts.push(script.name);
+    }
+  }
+  const profilePath = path32.join(hooksDestDir, "profile.json");
+  fs20.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
+  const claudeDir = path32.join(projectDir, ".claude");
+  fs20.mkdirSync(claudeDir, { recursive: true });
+  const settingsPath = path32.join(claudeDir, "settings.json");
+  let existing = {};
+  if (fs20.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
+    } catch (e) {
+      throw new Error(
+        `Malformed .claude/settings.json \u2014 fix the JSON syntax before running hooks init. Parse error: ${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+  }
+  const hooksConfig = buildSettingsHooks(profile);
+  const merged = mergeSettings(existing, hooksConfig);
+  fs20.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n");
+  return { copiedScripts, settingsPath, profilePath };
+}
+function createInitCommand3() {
+  return new Command39("init").description("Install Claude Code hook configurations into the current project").option("--profile <profile>", "Hook profile: minimal, standard, or strict", "standard").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const profile = opts.profile;
+    if (!VALID_PROFILES.includes(profile)) {
+      logger.error(`Invalid profile: ${profile}. Must be one of: ${VALID_PROFILES.join(", ")}`);
+      process.exit(2);
+    }
+    const projectDir = process.cwd();
+    try {
+      const result = initHooks({ profile, projectDir });
+      if (globalOpts.json) {
+        console.log(
+          JSON.stringify({
+            profile,
+            copiedScripts: result.copiedScripts,
+            settingsPath: result.settingsPath,
+            profilePath: result.profilePath
+          })
+        );
+      } else {
+        logger.success(
+          `Installed ${result.copiedScripts.length} hook scripts to .harness/hooks/`
+        );
+        logger.info(`Profile: ${profile}`);
+        logger.info(`Settings: ${path32.relative(projectDir, result.settingsPath)}`);
+        logger.dim("Run 'harness hooks list' to see installed hooks");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(`Failed to initialize hooks: ${message}`);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/hooks/list.ts
+import { Command as Command40 } from "commander";
+import * as fs21 from "fs";
+import * as path33 from "path";
+function listHooks(projectDir) {
+  const hooksDir = path33.join(projectDir, ".harness", "hooks");
+  const profilePath = path33.join(hooksDir, "profile.json");
+  if (!fs21.existsSync(profilePath)) {
+    return { installed: false, profile: null, hooks: [] };
+  }
+  let profile = "standard";
+  let warning;
+  try {
+    const data = JSON.parse(fs21.readFileSync(profilePath, "utf-8"));
+    if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
+      profile = data.profile;
+    }
+  } catch {
+    warning = "Malformed profile.json \u2014 defaulting to standard profile";
+  }
+  const activeNames = PROFILES[profile];
+  const hooks = HOOK_SCRIPTS.filter((h) => activeNames.includes(h.name)).map((h) => ({
+    name: h.name,
+    event: h.event,
+    matcher: h.matcher,
+    scriptPath: path33.join(".harness", "hooks", `${h.name}.js`)
+  }));
+  const result = { installed: true, profile, hooks };
+  if (warning) {
+    result.warning = warning;
+  }
+  return result;
+}
+function createListCommand3() {
+  return new Command40("list").description("Show installed hooks and active profile").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectDir = process.cwd();
+    const result = listHooks(projectDir);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.installed) {
+      logger.info("No harness hooks installed. Run 'harness hooks init' to set up hooks.");
+      return;
+    }
+    logger.info(`Profile: ${result.profile}`);
+    logger.info(`Hooks (${result.hooks.length}):`);
+    for (const hook of result.hooks) {
+      console.log(`  ${hook.name}  ${hook.event}:${hook.matcher}  ${hook.scriptPath}`);
+    }
+  });
+}
+
+// src/commands/hooks/remove.ts
+import { Command as Command41 } from "commander";
+import * as fs22 from "fs";
+import * as path34 from "path";
+function removeHooks(projectDir) {
+  const hooksDir = path34.join(projectDir, ".harness", "hooks");
+  const settingsPath = path34.join(projectDir, ".claude", "settings.json");
+  let removed = false;
+  let settingsCleaned = false;
+  if (fs22.existsSync(hooksDir)) {
+    fs22.rmSync(hooksDir, { recursive: true, force: true });
+    removed = true;
+  }
+  if (fs22.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+      if (settings.hooks !== void 0) {
+        delete settings.hooks;
+        settingsCleaned = true;
+        if (Object.keys(settings).length === 0) {
+          fs22.unlinkSync(settingsPath);
+        } else {
+          fs22.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        }
+      }
+    } catch {
+    }
+  }
+  return { removed, hooksDir, settingsCleaned };
+}
+function createRemoveCommand() {
+  return new Command41("remove").description("Remove harness-managed hooks from the current project").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectDir = process.cwd();
+    const result = removeHooks(projectDir);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result));
+      return;
+    }
+    if (!result.removed && !result.settingsCleaned) {
+      logger.info("No harness hooks found to remove.");
+      return;
+    }
+    if (result.removed) {
+      logger.success("Removed .harness/hooks/ directory");
+    }
+    if (result.settingsCleaned) {
+      logger.success("Cleaned hook entries from .claude/settings.json");
+    }
+  });
+}
+
+// src/commands/hooks/index.ts
+function createHooksCommand() {
+  const command = new Command42("hooks").description("Manage Claude Code hook configurations");
+  command.addCommand(createInitCommand3());
+  command.addCommand(createListCommand3());
+  command.addCommand(createRemoveCommand());
+  return command;
+}
+
 // src/commands/update.ts
-import { Command as Command37 } from "commander";
+import { Command as Command43 } from "commander";
 import { execFileSync as execFileSync4 } from "child_process";
 import { realpathSync } from "fs";
 import readline2 from "readline";
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -3533,10 +4081,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve29(answer.trim().toLowerCase());
+      resolve30(answer.trim().toLowerCase());
     });
   });
 }
@@ -3552,11 +4100,11 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk5.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
 }
 function createUpdateCommand() {
-  return new Command37("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
+  return new Command43("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const pm = detectPackageManager();
     if (globalOpts.verbose) {
@@ -3578,8 +4126,8 @@ function createUpdateCommand() {
       }
       if (currentVersion) {
         console.log("");
-        logger.info(`Current CLI version: ${chalk3.dim(`v${currentVersion}`)}`);
-        logger.info(`Latest CLI version:  ${chalk3.green(`v${latestCliVersion}`)}`);
+        logger.info(`Current CLI version: ${chalk5.dim(`v${currentVersion}`)}`);
+        logger.info(`Latest CLI version:  ${chalk5.green(`v${latestCliVersion}`)}`);
         console.log("");
       }
     }
@@ -3605,7 +4153,7 @@ function createUpdateCommand() {
     } catch {
       console.log("");
       logger.error("Update failed. You can try manually:");
-      console.log(`  ${chalk3.cyan(installCmd)}`);
+      console.log(`  ${chalk5.cyan(installCmd)}`);
       process.exit(ExitCode.ERROR);
     }
     await offerRegeneration();
@@ -3614,9 +4162,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/generate.ts
-import { Command as Command38 } from "commander";
+import { Command as Command44 } from "commander";
 function createGenerateCommand3() {
-  return new Command38("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
+  return new Command44("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platforms = opts.platforms.split(",").map((p) => p.trim());
     for (const p of platforms) {
@@ -3675,8 +4223,8 @@ function createGenerateCommand3() {
 }
 
 // src/commands/graph/scan.ts
-import { Command as Command39 } from "commander";
-import * as path29 from "path";
+import { Command as Command45 } from "commander";
+import * as path35 from "path";
 async function runScan(projectPath) {
   const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-B26DFXMP.js");
   const store = new GraphStore();
@@ -3689,13 +4237,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path29.join(projectPath, ".harness", "graph");
+  const graphDir = path35.join(projectPath, ".harness", "graph");
   await store.save(graphDir);
   return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
 }
 function createScanCommand() {
-  return new Command39("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
-    const projectPath = path29.resolve(inputPath);
+  return new Command45("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path35.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -3714,13 +4262,13 @@ function createScanCommand() {
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command40 } from "commander";
-import * as path30 from "path";
+import { Command as Command46 } from "commander";
+import * as path36 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs23 = await import("fs/promises");
-    const configPath = path30.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs23.readFile(configPath, "utf-8"));
+    const fs29 = await import("fs/promises");
+    const configPath = path36.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs29.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
     );
@@ -3760,7 +4308,7 @@ async function runIngest(projectPath, source, opts) {
     JiraConnector,
     SlackConnector
   } = await import("./dist-B26DFXMP.js");
-  const graphDir = path30.join(projectPath, ".harness", "graph");
+  const graphDir = path36.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -3821,13 +4369,13 @@ async function runIngest(projectPath, source, opts) {
   return result;
 }
 function createIngestCommand() {
-  return new Command40("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
+  return new Command46("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
     if (!opts.source && !opts.all) {
       console.error("Error: --source or --all is required");
       process.exit(1);
     }
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path30.resolve(globalOpts.config ? path30.dirname(globalOpts.config) : ".");
+    const projectPath = path36.resolve(globalOpts.config ? path36.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -3849,12 +4397,12 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/query.ts
-import { Command as Command41 } from "commander";
-import * as path31 from "path";
+import { Command as Command47 } from "commander";
+import * as path37 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
   const { GraphStore, ContextQL } = await import("./dist-B26DFXMP.js");
   const store = new GraphStore();
-  const graphDir = path31.join(projectPath, ".harness", "graph");
+  const graphDir = path37.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -3868,9 +4416,9 @@ async function runQuery(projectPath, rootNodeId, opts) {
   return cql.execute(params);
 }
 function createQueryCommand() {
-  return new Command41("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
+  return new Command47("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path31.resolve(globalOpts.config ? path31.dirname(globalOpts.config) : ".");
+    const projectPath = path37.resolve(globalOpts.config ? path37.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -3896,21 +4444,21 @@ function createQueryCommand() {
 }
 
 // src/commands/graph/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command48 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path32 from "path";
+import * as path38 from "path";
 async function runGraphStatus(projectPath) {
   const { GraphStore } = await import("./dist-B26DFXMP.js");
-  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const graphDir = path38.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
-  const fs23 = await import("fs/promises");
-  const metaPath = path32.join(graphDir, "metadata.json");
+  const fs29 = await import("fs/promises");
+  const metaPath = path38.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs23.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs29.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -3921,8 +4469,8 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path32.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs23.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path38.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs29.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -3939,10 +4487,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path33 from "path";
+import * as path39 from "path";
 async function runGraphExport(projectPath, format) {
   const { GraphStore } = await import("./dist-B26DFXMP.js");
-  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const graphDir = path39.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
@@ -3971,13 +4519,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path34 from "path";
+import * as path40 from "path";
 function createGraphCommand() {
-  const graph = new Command42("graph").description("Knowledge graph management");
+  const graph = new Command48("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
     try {
       const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path34.resolve(globalOpts.config ? path34.dirname(globalOpts.config) : ".");
+      const projectPath = path40.resolve(globalOpts.config ? path40.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -4004,7 +4552,7 @@ function createGraphCommand() {
   });
   graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path34.resolve(globalOpts.config ? path34.dirname(globalOpts.config) : ".");
+    const projectPath = path40.resolve(globalOpts.config ? path40.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);
@@ -4017,19 +4565,19 @@ function createGraphCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command43 } from "commander";
+import { Command as Command49 } from "commander";
 function createMcpCommand() {
-  return new Command43("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
-    const { startServer: startServer2 } = await import("./mcp-362EZHF4.js");
+  return new Command49("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
+    const { startServer: startServer2 } = await import("./mcp-VU5FMO52.js");
     await startServer2();
   });
 }
 
 // src/commands/impact-preview.ts
-import { Command as Command44 } from "commander";
+import { Command as Command50 } from "commander";
 import { execSync as execSync3 } from "child_process";
-import * as path35 from "path";
-import * as fs17 from "fs";
+import * as path41 from "path";
+import * as fs23 from "fs";
 function getStagedFiles(cwd) {
   try {
     const output = execSync3("git diff --cached --name-only", {
@@ -4043,7 +4591,7 @@ function getStagedFiles(cwd) {
 }
 function graphExists(projectPath) {
   try {
-    return fs17.existsSync(path35.join(projectPath, ".harness", "graph", "graph.json"));
+    return fs23.existsSync(path41.join(projectPath, ".harness", "graph", "graph.json"));
   } catch {
     return false;
   }
@@ -4052,7 +4600,7 @@ function extractNodeName(id) {
   const parts = id.split(":");
   if (parts.length > 1) {
     const fullPath = parts.slice(1).join(":");
-    return path35.basename(fullPath);
+    return path41.basename(fullPath);
   }
   return id;
 }
@@ -4175,7 +4723,7 @@ function formatPerFile(perFileResults) {
   return lines.join("\n");
 }
 async function runImpactPreview(options) {
-  const projectPath = path35.resolve(options.path ?? process.cwd());
+  const projectPath = path41.resolve(options.path ?? process.cwd());
   const stagedFiles = getStagedFiles(projectPath);
   if (stagedFiles.length === 0) {
     return "Impact Preview: no staged changes";
@@ -4222,7 +4770,7 @@ async function runImpactPreview(options) {
   return formatCompact(stagedFiles.length, merged, aggregateCounts);
 }
 function createImpactPreviewCommand() {
-  const command = new Command44("impact-preview").description("Show blast radius of staged changes using the knowledge graph").option("--detailed", "Show all affected files instead of top items").option("--per-file", "Show impact per staged file instead of aggregate").option("--path <dir>", "Project root (default: cwd)").action(async (opts) => {
+  const command = new Command50("impact-preview").description("Show blast radius of staged changes using the knowledge graph").option("--detailed", "Show all affected files instead of top items").option("--per-file", "Show impact per staged file instead of aggregate").option("--path <dir>", "Project root (default: cwd)").action(async (opts) => {
     const output = await runImpactPreview({
       detailed: opts.detailed,
       perFile: opts.perFile,
@@ -4235,7 +4783,7 @@ function createImpactPreviewCommand() {
 }
 
 // src/commands/check-arch.ts
-import { Command as Command45 } from "commander";
+import { Command as Command51 } from "commander";
 import { execSync as execSync4 } from "child_process";
 function getCommitHash2(cwd) {
   try {
@@ -4330,7 +4878,7 @@ async function runCheckArch(options) {
   });
 }
 function createCheckArchCommand() {
-  const command = new Command45("check-arch").description("Check architecture assertions against baseline and thresholds").option("--update-baseline", "Capture current state as new baseline").option("--module <path>", "Check a single module").action(async (opts, cmd) => {
+  const command = new Command51("check-arch").description("Check architecture assertions against baseline and thresholds").option("--update-baseline", "Capture current state as new baseline").option("--module <path>", "Check a single module").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -4396,20 +4944,20 @@ function createCheckArchCommand() {
 }
 
 // src/commands/blueprint.ts
-import { Command as Command46 } from "commander";
-import * as path36 from "path";
+import { Command as Command52 } from "commander";
+import * as path42 from "path";
 function createBlueprintCommand() {
-  return new Command46("blueprint").description("Generate a self-contained, interactive blueprint of the codebase").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory", "docs/blueprint").action(async (projectPath, options) => {
+  return new Command52("blueprint").description("Generate a self-contained, interactive blueprint of the codebase").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory", "docs/blueprint").action(async (projectPath, options) => {
     try {
-      const rootDir = path36.resolve(projectPath);
-      const outputDir = path36.resolve(options.output);
+      const rootDir = path42.resolve(projectPath);
+      const outputDir = path42.resolve(options.output);
       logger.info(`Scanning project at ${rootDir}...`);
       const scanner = new ProjectScanner(rootDir);
       const data = await scanner.scan();
       logger.info(`Generating blueprint to ${outputDir}...`);
       const generator = new BlueprintGenerator();
       await generator.generate(data, { outputDir });
-      logger.success(`Blueprint generated successfully at ${path36.join(outputDir, "index.html")}`);
+      logger.success(`Blueprint generated successfully at ${path42.join(outputDir, "index.html")}`);
     } catch (error) {
       logger.error(
         `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
@@ -4420,16 +4968,16 @@ function createBlueprintCommand() {
 }
 
 // src/commands/share.ts
-import { Command as Command47 } from "commander";
-import * as fs18 from "fs";
-import * as path37 from "path";
+import { Command as Command53 } from "commander";
+import * as fs24 from "fs";
+import * as path43 from "path";
 import { parse as parseYaml } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 function createShareCommand() {
-  return new Command47("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
-    const rootDir = path37.resolve(projectPath);
-    const manifestPath = path37.join(rootDir, MANIFEST_FILENAME);
-    if (!fs18.existsSync(manifestPath)) {
+  return new Command53("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
+    const rootDir = path43.resolve(projectPath);
+    const manifestPath = path43.join(rootDir, MANIFEST_FILENAME);
+    if (!fs24.existsSync(manifestPath)) {
       logger.error(
         `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -4438,7 +4986,7 @@ Create a constraints.yaml in your project root to define what to share.`
     }
     let parsed;
     try {
-      const raw = fs18.readFileSync(manifestPath, "utf-8");
+      const raw = fs24.readFileSync(manifestPath, "utf-8");
       parsed = parseYaml(raw);
     } catch (err) {
       logger.error(
@@ -4452,7 +5000,7 @@ Create a constraints.yaml in your project root to define what to share.`
       process.exit(1);
     }
     const manifest = manifestResult.value;
-    const configResult = resolveConfig(path37.join(rootDir, "harness.config.json"));
+    const configResult = resolveConfig(path43.join(rootDir, "harness.config.json"));
     if (!configResult.ok) {
       logger.error(configResult.error.message);
       process.exit(1);
@@ -4470,8 +5018,8 @@ Create a constraints.yaml in your project root to define what to share.`
       );
       process.exit(1);
     }
-    const outputDir = path37.resolve(options.output);
-    const outputPath = path37.join(outputDir, `${manifest.name}.harness-constraints.json`);
+    const outputDir = path43.resolve(options.output);
+    const outputPath = path43.join(outputDir, `${manifest.name}.harness-constraints.json`);
     const writeResult = await writeConfig(outputPath, bundle);
     if (!writeResult.ok) {
       logger.error(`Failed to write bundle: ${writeResult.error.message}`);
@@ -4482,25 +5030,25 @@ Create a constraints.yaml in your project root to define what to share.`
 }
 
 // src/commands/install.ts
-import * as fs20 from "fs";
-import * as path39 from "path";
-import { Command as Command48 } from "commander";
+import * as fs26 from "fs";
+import * as path45 from "path";
+import { Command as Command54 } from "commander";
 import { parse as yamlParse } from "yaml";
 
 // src/registry/tarball.ts
-import * as fs19 from "fs";
-import * as path38 from "path";
-import * as os3 from "os";
+import * as fs25 from "fs";
+import * as path44 from "path";
+import * as os6 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 function extractTarball(tarballBuffer) {
-  const tmpDir = fs19.mkdtempSync(path38.join(os3.tmpdir(), "harness-skill-install-"));
-  const tarballPath = path38.join(tmpDir, "package.tgz");
+  const tmpDir = fs25.mkdtempSync(path44.join(os6.tmpdir(), "harness-skill-install-"));
+  const tarballPath = path44.join(tmpDir, "package.tgz");
   try {
-    fs19.writeFileSync(tarballPath, tarballBuffer);
+    fs25.writeFileSync(tarballPath, tarballBuffer);
     execFileSync5("tar", ["-xzf", tarballPath, "-C", tmpDir], {
       timeout: 3e4
     });
-    fs19.unlinkSync(tarballPath);
+    fs25.unlinkSync(tarballPath);
   } catch (err) {
     cleanupTempDir(tmpDir);
     throw new Error(
@@ -4511,43 +5059,43 @@ function extractTarball(tarballBuffer) {
   return tmpDir;
 }
 function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
-  const files = fs19.readdirSync(extractedPkgDir);
+  const files = fs25.readdirSync(extractedPkgDir);
   for (const platform of platforms) {
-    const targetDir = path38.join(communityBaseDir, platform, skillName);
-    if (fs19.existsSync(targetDir)) {
-      fs19.rmSync(targetDir, { recursive: true, force: true });
+    const targetDir = path44.join(communityBaseDir, platform, skillName);
+    if (fs25.existsSync(targetDir)) {
+      fs25.rmSync(targetDir, { recursive: true, force: true });
     }
-    fs19.mkdirSync(targetDir, { recursive: true });
+    fs25.mkdirSync(targetDir, { recursive: true });
     for (const file of files) {
       if (file === "package.json" || file === "node_modules") continue;
-      const srcPath = path38.join(extractedPkgDir, file);
-      const destPath = path38.join(targetDir, file);
-      const stat = fs19.statSync(srcPath);
+      const srcPath = path44.join(extractedPkgDir, file);
+      const destPath = path44.join(targetDir, file);
+      const stat = fs25.statSync(srcPath);
       if (stat.isDirectory()) {
-        fs19.cpSync(srcPath, destPath, { recursive: true });
+        fs25.cpSync(srcPath, destPath, { recursive: true });
       } else {
-        fs19.copyFileSync(srcPath, destPath);
+        fs25.copyFileSync(srcPath, destPath);
       }
     }
   }
 }
 function removeSkillContent(communityBaseDir, skillName, platforms) {
   for (const platform of platforms) {
-    const targetDir = path38.join(communityBaseDir, platform, skillName);
-    if (fs19.existsSync(targetDir)) {
-      fs19.rmSync(targetDir, { recursive: true, force: true });
+    const targetDir = path44.join(communityBaseDir, platform, skillName);
+    if (fs25.existsSync(targetDir)) {
+      fs25.rmSync(targetDir, { recursive: true, force: true });
     }
   }
 }
 function cleanupTempDir(dirPath) {
   try {
-    fs19.rmSync(dirPath, { recursive: true, force: true });
+    fs25.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
 
 // src/registry/resolver.ts
-import semver2 from "semver";
+import semver3 from "semver";
 function resolveVersion(metadata, versionRange) {
   const versions = Object.keys(metadata.versions);
   if (versions.length === 0) {
@@ -4559,13 +5107,13 @@ function resolveVersion(metadata, versionRange) {
       const latestInfo = metadata.versions[latestTag];
       if (latestInfo) return latestInfo;
     }
-    const highest = semver2.maxSatisfying(versions, "*");
+    const highest = semver3.maxSatisfying(versions, "*");
     if (!highest || !metadata.versions[highest]) {
       throw new Error(`No versions available for ${metadata.name}.`);
     }
     return metadata.versions[highest];
   }
-  const matched = semver2.maxSatisfying(versions, versionRange);
+  const matched = semver3.maxSatisfying(versions, versionRange);
   if (!matched || !metadata.versions[matched]) {
     throw new Error(
       `No version of ${metadata.name} matches range ${versionRange}. Available: ${versions.join(", ")}`
@@ -4597,35 +5145,35 @@ function validateSkillYaml(parsed) {
   };
 }
 async function runLocalInstall(fromPath, options) {
-  const resolvedPath = path39.resolve(fromPath);
-  if (!fs20.existsSync(resolvedPath)) {
+  const resolvedPath = path45.resolve(fromPath);
+  if (!fs26.existsSync(resolvedPath)) {
     throw new Error(`--from path does not exist: ${resolvedPath}`);
   }
-  const stat = fs20.statSync(resolvedPath);
+  const stat = fs26.statSync(resolvedPath);
   let extractDir = null;
   let pkgDir;
   if (stat.isDirectory()) {
     pkgDir = resolvedPath;
   } else if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
-    const tarballBuffer = fs20.readFileSync(resolvedPath);
+    const tarballBuffer = fs26.readFileSync(resolvedPath);
     extractDir = extractTarball(tarballBuffer);
-    pkgDir = path39.join(extractDir, "package");
+    pkgDir = path45.join(extractDir, "package");
   } else {
     throw new Error(`--from path must be a directory or .tgz file. Got: ${resolvedPath}`);
   }
   try {
-    const skillYamlPath = path39.join(pkgDir, "skill.yaml");
-    if (!fs20.existsSync(skillYamlPath)) {
+    const skillYamlPath = path45.join(pkgDir, "skill.yaml");
+    if (!fs26.existsSync(skillYamlPath)) {
       throw new Error(`No skill.yaml found at ${skillYamlPath}`);
     }
-    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs26.readFileSync(skillYamlPath, "utf-8");
     const parsed = yamlParse(rawYaml);
     const skillYaml = validateSkillYaml(parsed);
     const shortName = skillYaml.name;
     const globalDir = resolveGlobalSkillsDir();
-    const skillsDir = path39.dirname(globalDir);
-    const communityBase = path39.join(skillsDir, "community");
-    const lockfilePath = path39.join(communityBase, "skills-lock.json");
+    const skillsDir = path45.dirname(globalDir);
+    const communityBase = path45.join(skillsDir, "community");
+    const lockfilePath = path45.join(communityBase, "skills-lock.json");
     const bundledNames = getBundledSkillNames(globalDir);
     if (bundledNames.has(shortName)) {
       throw new Error(
@@ -4666,9 +5214,9 @@ async function runInstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path39.dirname(globalDir);
-  const communityBase = path39.join(skillsDir, "community");
-  const lockfilePath = path39.join(communityBase, "skills-lock.json");
+  const skillsDir = path45.dirname(globalDir);
+  const communityBase = path45.join(skillsDir, "community");
+  const lockfilePath = path45.join(communityBase, "skills-lock.json");
   const bundledNames = getBundledSkillNames(globalDir);
   if (bundledNames.has(shortName)) {
     throw new Error(
@@ -4694,12 +5242,12 @@ async function runInstall(skillName, options) {
   const extractDir = extractTarball(tarballBuffer);
   let skillYaml;
   try {
-    const extractedPkgDir = path39.join(extractDir, "package");
-    const skillYamlPath = path39.join(extractedPkgDir, "skill.yaml");
-    if (!fs20.existsSync(skillYamlPath)) {
+    const extractedPkgDir = path45.join(extractDir, "package");
+    const skillYamlPath = path45.join(extractedPkgDir, "skill.yaml");
+    if (!fs26.existsSync(skillYamlPath)) {
       throw new Error(`contains invalid skill.yaml: file not found in package`);
     }
-    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs26.readFileSync(skillYamlPath, "utf-8");
     const parsed = yamlParse(rawYaml);
     skillYaml = validateSkillYaml(parsed);
     placeSkillContent(extractedPkgDir, communityBase, shortName, skillYaml.platforms);
@@ -4738,7 +5286,7 @@ async function runInstall(skillName, options) {
   return result;
 }
 function createInstallCommand() {
-  const cmd = new Command48("install");
+  const cmd = new Command54("install");
   cmd.description("Install a community skill from the @harness-skills registry").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--version <range>", "Semver range or exact version to install").option("--force", "Force reinstall even if same version is already installed").option("--from <path>", "Install from a local directory or .tgz file").option("--registry <url>", "Use a custom npm registry URL").action(async (skill, opts) => {
     try {
       const result = await runInstall(skill, opts);
@@ -4762,15 +5310,15 @@ function createInstallCommand() {
 }
 
 // src/commands/install-constraints.ts
-import * as fs21 from "fs/promises";
-import * as path40 from "path";
-import { Command as Command49 } from "commander";
-import semver3 from "semver";
+import * as fs27 from "fs/promises";
+import * as path46 from "path";
+import { Command as Command55 } from "commander";
+import semver4 from "semver";
 async function runInstallConstraints(options) {
   const { source, configPath, lockfilePath } = options;
   let rawBundle;
   try {
-    rawBundle = await fs21.readFile(source, "utf-8");
+    rawBundle = await fs27.readFile(source, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: false, error: `Bundle file not found: ${source}` };
@@ -4793,9 +5341,9 @@ async function runInstallConstraints(options) {
   }
   const bundle = bundleResult.data;
   if (bundle.minHarnessVersion) {
-    const installed = semver3.valid(semver3.coerce(CLI_VERSION));
-    const required = semver3.valid(semver3.coerce(bundle.minHarnessVersion));
-    if (installed && required && semver3.lt(installed, required)) {
+    const installed = semver4.valid(semver4.coerce(CLI_VERSION));
+    const required = semver4.valid(semver4.coerce(bundle.minHarnessVersion));
+    if (installed && required && semver4.lt(installed, required)) {
       return {
         ok: false,
         error: `Bundle requires harness version >= ${bundle.minHarnessVersion}, but installed version is ${CLI_VERSION}. Please upgrade.`
@@ -4813,7 +5361,7 @@ async function runInstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs21.readFile(configPath, "utf-8");
+    const raw = await fs27.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -4961,7 +5509,7 @@ function isNodeError(err) {
   return err instanceof Error && "code" in err;
 }
 function resolveConfigPath(opts) {
-  if (opts.config) return path40.resolve(opts.config);
+  if (opts.config) return path46.resolve(opts.config);
   const found = findConfigFile();
   if (!found.ok) {
     logger.error(found.error.message);
@@ -4996,9 +5544,9 @@ function logInstallResult(val, opts) {
 }
 async function handleInstallConstraints(source, opts) {
   const configPath = resolveConfigPath(opts);
-  const projectRoot = path40.dirname(configPath);
-  const lockfilePath = path40.join(projectRoot, ".harness", "constraints.lock.json");
-  const resolvedSource = path40.resolve(source);
+  const projectRoot = path46.dirname(configPath);
+  const lockfilePath = path46.join(projectRoot, ".harness", "constraints.lock.json");
+  const resolvedSource = path46.resolve(source);
   if (opts.forceLocal && opts.forcePackage) {
     logger.error("Cannot use both --force-local and --force-package.");
     process.exit(1);
@@ -5018,15 +5566,15 @@ async function handleInstallConstraints(source, opts) {
   logInstallResult(result.value, opts);
 }
 function createInstallConstraintsCommand() {
-  const cmd = new Command49("install-constraints");
+  const cmd = new Command55("install-constraints");
   cmd.description("Install a constraints bundle into the local harness config").argument("<source>", "Path to a .harness-constraints.json bundle file").option("--force-local", "Resolve all conflicts by keeping local values").option("--force-package", "Resolve all conflicts by using package values").option("--dry-run", "Show what would change without writing files").option("-c, --config <path>", "Path to harness.config.json").action(handleInstallConstraints);
   return cmd;
 }
 
 // src/commands/uninstall-constraints.ts
-import * as fs22 from "fs/promises";
-import * as path41 from "path";
-import { Command as Command50 } from "commander";
+import * as fs28 from "fs/promises";
+import * as path47 from "path";
+import { Command as Command56 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -5046,7 +5594,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs22.readFile(configPath, "utf-8");
+    const raw = await fs28.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -5083,11 +5631,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command50("uninstall-constraints");
+  const cmd = new Command56("uninstall-constraints");
   cmd.description("Remove a previously installed constraints package").argument("<name>", "Name of the constraint package to uninstall").option("-c, --config <path>", "Path to harness.config.json").action(async (name, opts) => {
     let configPath;
     if (opts.config) {
-      configPath = path41.resolve(opts.config);
+      configPath = path47.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -5096,8 +5644,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path41.dirname(configPath);
-    const lockfilePath = path41.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path47.dirname(configPath);
+    const lockfilePath = path47.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -5122,15 +5670,15 @@ function createUninstallConstraintsCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path42 from "path";
-import { Command as Command51 } from "commander";
+import * as path48 from "path";
+import { Command as Command57 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path42.dirname(globalDir);
-  const communityBase = path42.join(skillsDir, "community");
-  const lockfilePath = path42.join(communityBase, "skills-lock.json");
+  const skillsDir = path48.dirname(globalDir);
+  const communityBase = path48.join(skillsDir, "community");
+  const lockfilePath = path48.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -5160,7 +5708,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command51("uninstall");
+  const cmd = new Command57("uninstall");
   cmd.description("Uninstall a community skill").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--force", "Remove even if other skills depend on this one").action(async (skill, opts) => {
     try {
       const result = await runUninstall(skill, opts);
@@ -5179,13 +5727,13 @@ function createUninstallCommand() {
 }
 
 // src/commands/orchestrator.ts
-import { Command as Command52 } from "commander";
-import * as path43 from "path";
+import { Command as Command58 } from "commander";
+import * as path49 from "path";
 import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command52("orchestrator");
+  const orchestrator = new Command58("orchestrator");
   orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to WORKFLOW.md", "WORKFLOW.md").action(async (opts) => {
-    const workflowPath = path43.resolve(process.cwd(), opts.workflow);
+    const workflowPath = path49.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -5209,13 +5757,13 @@ function createOrchestratorCommand() {
 }
 
 // src/commands/learnings/index.ts
-import { Command as Command54 } from "commander";
+import { Command as Command60 } from "commander";
 
 // src/commands/learnings/prune.ts
-import { Command as Command53 } from "commander";
-import * as path44 from "path";
+import { Command as Command59 } from "commander";
+import * as path50 from "path";
 async function handlePrune(opts) {
-  const projectPath = path44.resolve(opts.path);
+  const projectPath = path50.resolve(opts.path);
   const result = await pruneLearnings(projectPath, opts.stream);
   if (!result.ok) {
     logger.error(result.error.message);
@@ -5254,21 +5802,21 @@ function printPatternProposals(patterns) {
   );
 }
 function createPruneCommand() {
-  return new Command53("prune").description(
+  return new Command59("prune").description(
     "Analyze global learnings for patterns, present improvement proposals, and archive old entries"
   ).option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(handlePrune);
 }
 
 // src/commands/learnings/index.ts
 function createLearningsCommand() {
-  const command = new Command54("learnings").description("Learnings management commands");
+  const command = new Command60("learnings").description("Learnings management commands");
   command.addCommand(createPruneCommand());
   return command;
 }
 
 // src/index.ts
 function createProgram() {
-  const program = new Command55();
+  const program = new Command61();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
@@ -5289,10 +5837,13 @@ function createProgram() {
   program.addCommand(createCheckPhaseGateCommand());
   program.addCommand(createCreateSkillCommand());
   program.addCommand(createSetupMcpCommand());
+  program.addCommand(createSetupCommand());
+  program.addCommand(createDoctorCommand());
   program.addCommand(createGenerateSlashCommandsCommand());
   program.addCommand(createGenerateAgentDefinitionsCommand());
   program.addCommand(createGenerateCommand3());
   program.addCommand(createCICommand());
+  program.addCommand(createHooksCommand());
   program.addCommand(createUpdateCommand());
   program.addCommand(createScanCommand());
   program.addCommand(createIngestCommand());
@@ -5313,6 +5864,7 @@ function createProgram() {
 
 export {
   buildPreamble,
+  printFirstRunWelcome,
   runScan,
   runIngest,
   runQuery,