@harness-engineering/cli 1.13.1 → 1.15.0

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

@@ -1,20 +1,20 @@
 import {
   generateCIWorkflow
-} from "./chunk-VUCPTQ6G.js";
+} from "./chunk-SD3SQOZ2.js";
 import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-UAX4I5ZE.js";
+} from "./chunk-LGYBN7Y6.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-TS3XWPW5.js";
+} from "./chunk-RCWZBSK5.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-Q6AB7W5Z.js";
+} from "./chunk-YQ6KC6TE.js";
 import {
   runPersona
 } from "./chunk-TRAPF4IX.js";
@@ -33,29 +33,31 @@ import {
 import {
   generate,
   validate
-} from "./chunk-QPEH2QPG.js";
+} from "./chunk-DBSOCI3G.js";
 import {
   generateRuntime
-} from "./chunk-JSTQ3AWB.js";
+} from "./chunk-FIAPHX37.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   generateAgentsMd
-} from "./chunk-NKDM3FMH.js";
+} from "./chunk-OD3S2NHN.js";
 import {
+  appendFrameworkAgents,
   createGenerateSlashCommandsCommand,
   generateSlashCommands,
   handleGetImpact,
-  handleOrphanDeletion
-} from "./chunk-NERR4TAO.js";
+  handleOrphanDeletion,
+  persistToolingConfig
+} from "./chunk-NNHDDXYT.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-ZOAWBDWU.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-Z77YQRQT.js";
+} from "./chunk-B2HKP423.js";
 import {
   resolveGlobalSkillsDir,
   resolvePersonasDir,
@@ -76,7 +78,7 @@ import {
 } from "./chunk-BM3PWGXQ.js";
 import {
   TemplateEngine
-} from "./chunk-C2ERUR3L.js";
+} from "./chunk-7MJAPE3Z.js";
 import {
   ArchBaselineManager,
   ArchConfigSchema,
@@ -125,14 +127,14 @@ import {
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-PQ5YK4AY.js";
+} from "./chunk-Z2OOPXJO.js";
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} 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";
@@ -211,7 +213,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-STFHYMAZ.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");
@@ -479,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 ?? {};
     }
@@ -564,12 +566,11 @@ function createCheckSecurityCommand() {
 // src/commands/perf.ts
 import { Command as Command5 } from "commander";
 import * as path5 from "path";
-function createPerfCommand() {
-  const perf = new Command5("perf").description("Performance benchmark and baseline management");
+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-2B363XUH.js");
+    const { BenchmarkRunner } = await import("./dist-ALQDD67R.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
@@ -580,48 +581,47 @@ function createPerfCommand() {
       }
       return;
     }
-    if (globalOpts.json) {
-      logger.info(`Found ${benchFiles.length} benchmark file(s). Running...`);
-    } else {
-      logger.info(`Found ${benchFiles.length} benchmark file(s):`);
-      for (const f of benchFiles) {
-        logger.info(`  ${f}`);
-      }
-      logger.info("Running benchmarks...");
-    }
+    logBenchDiscovery(globalOpts.json, benchFiles);
     const result = await runner.run(glob ? { cwd, glob } : { cwd });
-    if (globalOpts.json) {
-      console.log(JSON.stringify({ results: result.results, success: result.success }));
-    } else {
-      if (result.success && result.results.length > 0) {
-        logger.info(`
+    outputBenchResults(globalOpts.json, result);
+  });
+}
+function logBenchDiscovery(json, benchFiles) {
+  if (json) {
+    logger.info(`Found ${benchFiles.length} benchmark file(s). Running...`);
+  } else {
+    logger.info(`Found ${benchFiles.length} benchmark file(s):`);
+    for (const f of benchFiles) logger.info(`  ${f}`);
+    logger.info("Running benchmarks...");
+  }
+}
+function outputBenchResults(json, result) {
+  if (json) {
+    console.log(JSON.stringify({ results: result.results, success: result.success }));
+    return;
+  }
+  if (result.success && result.results.length > 0) {
+    logger.info(`
 Results (${result.results.length} benchmarks):`);
-        for (const r of result.results) {
-          logger.info(
-            `  ${r.file}::${r.name}: ${r.opsPerSec} ops/s (mean: ${r.meanMs.toFixed(2)}ms)`
-          );
-        }
-        logger.info("\nTo save as baselines: harness perf baselines update");
-      } else {
-        logger.info("Benchmark run completed. Check output above for details.");
-        if (result.rawOutput) {
-          console.log(result.rawOutput);
-        }
-      }
+    for (const r of result.results) {
+      logger.info(`  ${r.file}::${r.name}: ${r.opsPerSec} ops/s (mean: ${r.meanMs.toFixed(2)}ms)`);
     }
-  });
+    logger.info("\nTo save as baselines: harness perf baselines update");
+  } else {
+    logger.info("Benchmark run completed. Check output above for details.");
+    if (result.rawOutput) console.log(result.rawOutput);
+  }
+}
+function registerBaselinesCommands(perf) {
   const baselines = perf.command("baselines").description("Manage performance baselines");
   baselines.command("show").description("Display current baselines").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const cwd = process.cwd();
-    const manager = new BaselineManager(cwd);
+    const manager = new BaselineManager(process.cwd());
     const data = manager.load();
     if (!data) {
-      if (globalOpts.json) {
-        console.log(JSON.stringify({ baselines: null, message: "No baselines file found" }));
-      } else {
-        logger.info("No baselines file found at .harness/perf/baselines.json");
-      }
+      console.log(
+        globalOpts.json ? JSON.stringify({ baselines: null, message: "No baselines file found" }) : "No baselines file found at .harness/perf/baselines.json"
+      );
       return;
     }
     if (globalOpts.json) {
@@ -638,7 +638,7 @@ Results (${result.results.length} benchmarks):`);
   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-2B363XUH.js");
+    const { BenchmarkRunner } = await import("./dist-ALQDD67R.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -649,12 +649,7 @@ Results (${result.results.length} benchmarks):`);
       );
       return;
     }
-    let commitHash = "unknown";
-    try {
-      const { execSync: execSync5 } = await import("child_process");
-      commitHash = execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
-    } catch {
-    }
+    const commitHash = await getCommitHash(cwd);
     manager.save(benchResult.results, commitHash);
     if (globalOpts.json) {
       console.log(JSON.stringify({ updated: benchResult.results.length, commitHash }));
@@ -663,10 +658,20 @@ Results (${result.results.length} benchmarks):`);
       logger.info("Baselines saved to .harness/perf/baselines.json");
     }
   });
+}
+async function getCommitHash(cwd) {
+  try {
+    const { execSync: execSync5 } = await import("child_process");
+    return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+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-2B363XUH.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-ALQDD67R.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -703,10 +708,11 @@ Results (${result.results.length} benchmarks):`);
       }
     }
   });
+}
+function registerCriticalPathsCommand(perf) {
   perf.command("critical-paths").description("Show resolved critical path set (annotations + graph inference)").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const cwd = process.cwd();
-    const resolver = new CriticalPathResolver(cwd);
+    const resolver = new CriticalPathResolver(process.cwd());
     const result = await resolver.resolve();
     if (globalOpts.json) {
       console.log(JSON.stringify(result, null, 2));
@@ -721,12 +727,29 @@ Results (${result.results.length} benchmarks):`);
       }
     }
   });
+}
+function createPerfCommand() {
+  const perf = new Command5("perf").description("Performance benchmark and baseline management");
+  registerBenchCommand(perf);
+  registerBaselinesCommands(perf);
+  registerReportCommand(perf);
+  registerCriticalPathsCommand(perf);
   return perf;
 }
 
 // src/commands/check-docs.ts
 import { Command as Command6 } from "commander";
 import * as path6 from "path";
+
+// src/utils/output.ts
+function resolveOutputMode(globalOpts) {
+  if (globalOpts.json) return OutputMode.JSON;
+  if (globalOpts.quiet) return OutputMode.QUIET;
+  if (globalOpts.verbose) return OutputMode.VERBOSE;
+  return OutputMode.TEXT;
+}
+
+// src/commands/check-docs.ts
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
   const minCoverage = options.minCoverage ?? 80;
@@ -777,7 +800,7 @@ async function runCheckDocs(options) {
 function createCheckDocsCommand() {
   const command = new Command6("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").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 mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runCheckDocs({
       configPath: globalOpts.config,
@@ -947,7 +970,6 @@ function createSetupMcpCommand() {
 async function runInit(options) {
   const cwd = options.cwd ?? process.cwd();
   const name = options.name ?? path8.basename(cwd);
-  const level = options.level ?? "basic";
   const force = options.force ?? false;
   const configPath = path8.join(cwd, "harness.config.json");
   if (!force && fs2.existsSync(configPath)) {
@@ -955,33 +977,82 @@ async function runInit(options) {
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
   }
-  const templatesDir = resolveTemplatesDir();
-  const engine = new TemplateEngine(templatesDir);
-  const resolveResult = engine.resolveTemplate(level, options.framework);
-  if (!resolveResult.ok) {
-    return Err(new CLIError(resolveResult.error.message, ExitCode.ERROR));
+  const engine = new TemplateEngine(resolveTemplatesDir());
+  const templates = engine.listTemplates();
+  const templateList = templates.ok ? templates.value : [];
+  const validationError = validateFrameworkLanguage(options, templateList);
+  if (validationError) return Err(validationError);
+  const detected = tryAutoDetect(engine, cwd, options);
+  if (detected) return Ok(detected);
+  const language = resolveLanguage(options, templateList);
+  return scaffoldProject(engine, { cwd, name, force, language, options });
+}
+function validateFrameworkLanguage(options, templateList) {
+  if (!options.framework || !options.language) return null;
+  const fwTemplate = templateList.find((t) => t.framework === options.framework);
+  if (fwTemplate?.language && fwTemplate.language !== options.language) {
+    return new CLIError(
+      `Framework "${options.framework}" is a ${fwTemplate.language} framework, but --language ${options.language} was specified. Remove --language or use --language ${fwTemplate.language}.`,
+      ExitCode.ERROR
+    );
+  }
+  return null;
+}
+function tryAutoDetect(engine, cwd, options) {
+  if (options.framework || options.language) return null;
+  const detectResult = engine.detectFramework(cwd);
+  if (detectResult.ok && detectResult.value.length > 0) {
+    return { filesCreated: [], skippedConfigs: [], detectedFrameworks: detectResult.value };
+  }
+  return null;
+}
+function resolveLanguage(options, templateList) {
+  if (options.language) return options.language;
+  if (options.framework) {
+    const fwTemplate = templateList.find((t) => t.framework === options.framework);
+    if (fwTemplate?.language) return fwTemplate.language;
   }
+  return void 0;
+}
+function scaffoldProject(engine, ctx) {
+  const { cwd, name, force, language, options } = ctx;
+  const isNonJs = language && language !== "typescript";
+  const level = isNonJs ? void 0 : options.level ?? "basic";
+  const resolveResult = engine.resolveTemplate(level, options.framework, language);
+  if (!resolveResult.ok) return Err(new CLIError(resolveResult.error.message, ExitCode.ERROR));
   const renderResult = engine.render(resolveResult.value, {
     projectName: name,
-    level,
-    ...options.framework !== void 0 && { framework: options.framework }
+    level: level ?? "",
+    ...options.framework !== void 0 && { framework: options.framework },
+    ...language !== void 0 && { language }
   });
-  if (!renderResult.ok) {
-    return Err(new CLIError(renderResult.error.message, ExitCode.ERROR));
-  }
-  const writeResult = engine.write(renderResult.value, cwd, { overwrite: force });
-  if (!writeResult.ok) {
-    return Err(new CLIError(writeResult.error.message, ExitCode.ERROR));
+  if (!renderResult.ok) return Err(new CLIError(renderResult.error.message, ExitCode.ERROR));
+  const writeResult = engine.write(renderResult.value, cwd, {
+    overwrite: force,
+    ...language !== void 0 && { language }
+  });
+  if (!writeResult.ok) return Err(new CLIError(writeResult.error.message, ExitCode.ERROR));
+  if (writeResult.value.skippedConfigs.length > 0) {
+    logger.warn("Skipped existing package config files:");
+    for (const file of writeResult.value.skippedConfigs) {
+      logger.info(`  - ${file} (add harness dependencies manually)`);
+    }
   }
-  return Ok({ filesCreated: writeResult.value });
+  persistToolingConfig(cwd, resolveResult.value, options.framework);
+  appendFrameworkAgents(cwd, options.framework, language);
+  return Ok({
+    filesCreated: writeResult.value.written,
+    skippedConfigs: writeResult.value.skippedConfigs
+  });
 }
 function createInitCommand() {
-  const command = new Command8("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
+  const command = new Command8("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("--language <language>", "Target language (typescript, python, go, rust, java)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const result = await runInit({
       name: opts.name,
       level: opts.level,
       framework: opts.framework,
+      language: opts.language,
       force: opts.force
     });
     if (!result.ok) {
@@ -1077,10 +1148,39 @@ async function runCleanup(options) {
   result.totalIssues = result.driftIssues.length + result.deadCode.length + result.patternViolations.length;
   return Ok(result);
 }
+function printCleanupResult(value, formatter) {
+  console.log(
+    formatter.formatSummary("Entropy issues", value.totalIssues.toString(), value.totalIssues === 0)
+  );
+  if (value.driftIssues.length > 0) {
+    console.log("\nDocumentation drift:");
+    for (const issue of value.driftIssues) {
+      console.log(`  - ${issue.file}: ${issue.issue}`);
+    }
+  }
+  if (value.deadCode.length > 0) {
+    console.log("\nDead code:");
+    for (const item of value.deadCode.slice(0, 10)) {
+      console.log(`  - ${item.file}${item.symbol ? `: ${item.symbol}` : ""}`);
+    }
+    if (value.deadCode.length > 10) {
+      console.log(`  ... and ${value.deadCode.length - 10} more`);
+    }
+  }
+  if (value.patternViolations.length > 0) {
+    console.log("\nPattern violations:");
+    for (const violation of value.patternViolations.slice(0, 10)) {
+      console.log(`  - ${violation.file} [${violation.pattern}]: ${violation.message}`);
+    }
+    if (value.patternViolations.length > 10) {
+      console.log(`  ... and ${value.patternViolations.length - 10} more`);
+    }
+  }
+}
 function createCleanupCommand() {
   const command = new Command9("cleanup").description("Detect entropy issues (doc drift, dead code, patterns)").option("-t, --type <type>", "Issue type: drift, dead-code, patterns, all", "all").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 mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runCleanup({
       configPath: globalOpts.config,
@@ -1100,37 +1200,7 @@ function createCleanupCommand() {
     if (mode === OutputMode.JSON) {
       console.log(JSON.stringify(result.value, null, 2));
     } else if (mode !== OutputMode.QUIET || result.value.totalIssues > 0) {
-      console.log(
-        formatter.formatSummary(
-          "Entropy issues",
-          result.value.totalIssues.toString(),
-          result.value.totalIssues === 0
-        )
-      );
-      if (result.value.driftIssues.length > 0) {
-        console.log("\nDocumentation drift:");
-        for (const issue of result.value.driftIssues) {
-          console.log(`  - ${issue.file}: ${issue.issue}`);
-        }
-      }
-      if (result.value.deadCode.length > 0) {
-        console.log("\nDead code:");
-        for (const item of result.value.deadCode.slice(0, 10)) {
-          console.log(`  - ${item.file}${item.symbol ? `: ${item.symbol}` : ""}`);
-        }
-        if (result.value.deadCode.length > 10) {
-          console.log(`  ... and ${result.value.deadCode.length - 10} more`);
-        }
-      }
-      if (result.value.patternViolations.length > 0) {
-        console.log("\nPattern violations:");
-        for (const violation of result.value.patternViolations.slice(0, 10)) {
-          console.log(`  - ${violation.file} [${violation.pattern}]: ${violation.message}`);
-        }
-        if (result.value.patternViolations.length > 10) {
-          console.log(`  ... and ${result.value.patternViolations.length - 10} more`);
-        }
-      }
+      printCleanupResult(result.value, formatter);
     }
     process.exit(result.value.totalIssues === 0 ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
   });
@@ -1238,10 +1308,42 @@ async function runFixDrift(options) {
   };
   return Ok(result);
 }
+function printFixDriftResult(value, mode, formatter) {
+  const statusMessage = value.dryRun ? "(dry-run)" : "";
+  console.log(
+    formatter.formatSummary(
+      `Fix drift ${statusMessage}`,
+      `${value.fixes.length} fixes, ${value.suggestions.length} suggestions`,
+      value.fixes.length === 0 && value.suggestions.length === 0
+    )
+  );
+  if (value.fixes.length > 0) {
+    console.log("\nFixes:");
+    for (const fix of value.fixes.slice(0, 10)) {
+      const status = fix.applied ? "[applied]" : "[pending]";
+      console.log(`  ${status} ${fix.action}: ${fix.file}`);
+    }
+    if (value.fixes.length > 10) {
+      console.log(`  ... and ${value.fixes.length - 10} more`);
+    }
+  }
+  if (value.suggestions.length > 0 && (mode === OutputMode.VERBOSE || value.fixes.length === 0)) {
+    console.log("\nSuggestions:");
+    for (const suggestion of value.suggestions.slice(0, 10)) {
+      console.log(`  - ${suggestion.file}: ${suggestion.suggestion}`);
+    }
+    if (value.suggestions.length > 10) {
+      console.log(`  ... and ${value.suggestions.length - 10} more`);
+    }
+  }
+  if (value.dryRun && value.fixes.length > 0) {
+    console.log("\nRun with --no-dry-run to apply fixes.");
+  }
+}
 function createFixDriftCommand() {
   const command = new Command10("fix-drift").description("Auto-fix entropy issues (doc drift, dead code)").option("--no-dry-run", "Actually apply fixes (default is dry-run mode)").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 mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runFixDrift({
       configPath: globalOpts.config,
@@ -1261,37 +1363,7 @@ function createFixDriftCommand() {
     if (mode === OutputMode.JSON) {
       console.log(JSON.stringify(result.value, null, 2));
     } else if (mode !== OutputMode.QUIET || result.value.fixes.length > 0 || result.value.suggestions.length > 0) {
-      const { value } = result;
-      const statusMessage = value.dryRun ? "(dry-run)" : "";
-      console.log(
-        formatter.formatSummary(
-          `Fix drift ${statusMessage}`,
-          `${value.fixes.length} fixes, ${value.suggestions.length} suggestions`,
-          value.fixes.length === 0 && value.suggestions.length === 0
-        )
-      );
-      if (value.fixes.length > 0) {
-        console.log("\nFixes:");
-        for (const fix of value.fixes.slice(0, 10)) {
-          const status = fix.applied ? "[applied]" : "[pending]";
-          console.log(`  ${status} ${fix.action}: ${fix.file}`);
-        }
-        if (value.fixes.length > 10) {
-          console.log(`  ... and ${value.fixes.length - 10} more`);
-        }
-      }
-      if (value.suggestions.length > 0 && (mode === OutputMode.VERBOSE || value.fixes.length === 0)) {
-        console.log("\nSuggestions:");
-        for (const suggestion of value.suggestions.slice(0, 10)) {
-          console.log(`  - ${suggestion.file}: ${suggestion.suggestion}`);
-        }
-        if (value.suggestions.length > 10) {
-          console.log(`  ... and ${value.suggestions.length - 10} more`);
-        }
-      }
-      if (value.dryRun && value.fixes.length > 0) {
-        console.log("\nRun with --no-dry-run to apply fixes.");
-      }
+      printFixDriftResult(result.value, mode, formatter);
     }
     process.exit(ExitCode.SUCCESS);
   });
@@ -1356,49 +1428,54 @@ var VALID_TRIGGERS = /* @__PURE__ */ new Set([
   "on_plan_approved",
   "auto"
 ]);
+function resolveTrigger(triggerOpt) {
+  if (triggerOpt === "auto") return "auto";
+  return VALID_TRIGGERS.has(triggerOpt) ? triggerOpt : "manual";
+}
+function createCommandExecutor() {
+  return async (command) => {
+    if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
+      return Err(new Error(`Unknown harness command: ${command}`));
+    }
+    try {
+      childProcess.execFileSync("npx", ["harness", command], { stdio: "inherit" });
+      return Ok(null);
+    } catch (error) {
+      return Err(new Error(error instanceof Error ? error.message : String(error)));
+    }
+  };
+}
+async function runPersonaMode(opts, quiet) {
+  const personasDir = resolvePersonasDir();
+  const filePath = path11.join(personasDir, `${opts.persona}.yaml`);
+  const personaResult = loadPersona(filePath);
+  if (!personaResult.ok) {
+    logger.error(personaResult.error.message);
+    process.exit(ExitCode.ERROR);
+  }
+  const report = await runPersona(personaResult.value, {
+    trigger: resolveTrigger(opts.trigger),
+    commandExecutor: createCommandExecutor(),
+    skillExecutor: executeSkill,
+    projectPath: process.cwd()
+  });
+  if (!quiet) {
+    logger.info(`Persona '${report.persona}' status: ${report.status}`);
+    for (const s of report.steps) {
+      const icon = s.status === "pass" ? "v" : s.status === "fail" ? "x" : "-";
+      const typeTag = s.type === "skill" ? " [skill]" : "";
+      console.log(`  [${icon}] ${s.name}${typeTag} (${s.durationMs}ms)`);
+      if (s.artifactPath) console.log(`      artifact: ${s.artifactPath}`);
+    }
+  }
+  process.exit(report.status === "fail" ? ExitCode.ERROR : ExitCode.SUCCESS);
+}
 function createRunCommand() {
   return new Command11("run").description("Run an agent task").argument("[task]", "Task to run (review, doc-review, test-review)").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--persona <name>", "Run a persona by name").option("--trigger <context>", "Trigger context (auto, on_pr, on_commit, manual)", "auto").action(async (task, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     if (opts.persona) {
-      const personasDir = resolvePersonasDir();
-      const filePath = path11.join(personasDir, `${opts.persona}.yaml`);
-      const personaResult = loadPersona(filePath);
-      if (!personaResult.ok) {
-        logger.error(personaResult.error.message);
-        process.exit(ExitCode.ERROR);
-      }
-      const persona = personaResult.value;
-      const projectPath = process.cwd();
-      const trigger = opts.trigger === "auto" ? "auto" : VALID_TRIGGERS.has(opts.trigger) ? opts.trigger : "manual";
-      const commandExecutor = async (command) => {
-        if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
-          return Err(new Error(`Unknown harness command: ${command}`));
-        }
-        try {
-          childProcess.execFileSync("npx", ["harness", command], { stdio: "inherit" });
-          return Ok(null);
-        } catch (error) {
-          return Err(new Error(error instanceof Error ? error.message : String(error)));
-        }
-      };
-      const report = await runPersona(persona, {
-        trigger,
-        commandExecutor,
-        skillExecutor: executeSkill,
-        projectPath
-      });
-      if (!globalOpts.quiet) {
-        logger.info(`Persona '${report.persona}' status: ${report.status}`);
-        for (const s of report.steps) {
-          const icon = s.status === "pass" ? "v" : s.status === "fail" ? "x" : "-";
-          const typeTag = s.type === "skill" ? " [skill]" : "";
-          console.log(`  [${icon}] ${s.name}${typeTag} (${s.durationMs}ms)`);
-          if (s.artifactPath) {
-            console.log(`      artifact: ${s.artifactPath}`);
-          }
-        }
-      }
-      process.exit(report.status === "fail" ? ExitCode.ERROR : ExitCode.SUCCESS);
+      await runPersonaMode(opts, globalOpts.quiet);
+      return;
     }
     if (!task) {
       logger.error("Either a task argument or --persona flag is required.");
@@ -1987,6 +2064,33 @@ function scanDirectory(dirPath, source) {
   }
   return skills;
 }
+function collectCommunitySkills(seen, allSkills) {
+  const globalDir = resolveGlobalSkillsDir();
+  const skillsDir = path15.dirname(globalDir);
+  const communityBase = path15.join(skillsDir, "community");
+  const communityPlatformDir = path15.join(communityBase, "claude-code");
+  const lockfilePath = path15.join(communityBase, "skills-lock.json");
+  const lockfile = readLockfile2(lockfilePath);
+  const communitySkills = scanDirectory(communityPlatformDir, "community");
+  for (const skill of communitySkills) {
+    const lockEntry = lockfile.skills[`@harness-skills/${skill.name}`];
+    if (lockEntry) skill.version = lockEntry.version;
+  }
+  for (const [pkgName, entry] of Object.entries(lockfile.skills)) {
+    const shortName = pkgName.replace("@harness-skills/", "");
+    if (!seen.has(shortName)) {
+      seen.add(shortName);
+      allSkills.push({
+        name: shortName,
+        description: "",
+        type: "",
+        source: "community",
+        version: entry.version
+      });
+    }
+  }
+  return communitySkills;
+}
 function collectSkills(opts) {
   const seen = /* @__PURE__ */ new Set();
   const allSkills = [];
@@ -2005,34 +2109,7 @@ function collectSkills(opts) {
     }
   }
   if (opts.filter === "all" || opts.filter === "installed") {
-    const globalDir = resolveGlobalSkillsDir();
-    const skillsDir = path15.dirname(globalDir);
-    const communityBase = path15.join(skillsDir, "community");
-    const communityPlatformDir = path15.join(communityBase, "claude-code");
-    const lockfilePath = path15.join(communityBase, "skills-lock.json");
-    const lockfile = readLockfile2(lockfilePath);
-    const communitySkills = scanDirectory(communityPlatformDir, "community");
-    for (const skill of communitySkills) {
-      const pkgName = `@harness-skills/${skill.name}`;
-      const lockEntry = lockfile.skills[pkgName];
-      if (lockEntry) {
-        skill.version = lockEntry.version;
-      }
-    }
-    addUnique(communitySkills);
-    for (const [pkgName, entry] of Object.entries(lockfile.skills)) {
-      const shortName = pkgName.replace("@harness-skills/", "");
-      if (!seen.has(shortName)) {
-        seen.add(shortName);
-        allSkills.push({
-          name: shortName,
-          description: "",
-          type: "",
-          source: "community",
-          version: entry.version
-        });
-      }
-    }
+    addUnique(collectCommunitySkills(seen, allSkills));
   }
   if (opts.filter === "all") {
     const globalDir = resolveGlobalSkillsDir();
@@ -2166,6 +2243,69 @@ ${options.priorState}`);
 }
 
 // src/commands/skill/run.ts
+function loadSkillMetadata(skillDir) {
+  const yamlPath = path16.join(skillDir, "skill.yaml");
+  if (!fs7.existsSync(yamlPath)) return null;
+  try {
+    const result = SkillMetadataSchema.safeParse(parse2(fs7.readFileSync(yamlPath, "utf-8")));
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function resolveComplexity(metadata, requested, projectPath) {
+  if (!metadata?.phases || metadata.phases.length === 0) return void 0;
+  if (requested === "auto") return detectComplexity(projectPath);
+  return requested;
+}
+function loadPrinciples(projectPath) {
+  const principlesPath = path16.join(projectPath, "docs", "principles.md");
+  return fs7.existsSync(principlesPath) ? fs7.readFileSync(principlesPath, "utf-8") : void 0;
+}
+function readMostRecentFileInDir(dirPath) {
+  const files = fs7.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs7.statSync(path16.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs7.readFileSync(path16.join(dirPath, files[0].name), "utf-8");
+  return void 0;
+}
+function loadPriorState(metadata, projectPath) {
+  if (!metadata?.state.persistent || metadata.state.files.length === 0) return void 0;
+  for (const stateFilePath of metadata.state.files) {
+    const fullPath = path16.join(projectPath, stateFilePath);
+    if (!fs7.existsSync(fullPath)) continue;
+    const stat = fs7.statSync(fullPath);
+    if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
+    return fs7.readFileSync(fullPath, "utf-8");
+  }
+  return void 0;
+}
+function validatePhaseName(metadata, phase) {
+  if (!metadata?.phases) return true;
+  return metadata.phases.map((p) => p.name).includes(phase);
+}
+function resolvePhaseState(metadata, projectPath, phase) {
+  if (!validatePhaseName(metadata, phase)) {
+    const validPhases = metadata.phases.map((p) => p.name);
+    logger.error(`Unknown phase: ${phase}. Valid phases: ${validPhases.join(", ")}`);
+    return null;
+  }
+  const priorState = loadPriorState(metadata, projectPath);
+  const stateWarning = !priorState && metadata?.state.persistent ? "No prior phase data found. Earlier phases have not been completed. Proceed with caution." : void 0;
+  return { priorState, stateWarning };
+}
+function appendProjectState(content, metadata, projectPath, hasPathOpt) {
+  if (!metadata?.state.persistent || !hasPathOpt) return content;
+  const stateFile = path16.join(projectPath, ".harness", "state.json");
+  if (!fs7.existsSync(stateFile)) return content;
+  const stateContent = fs7.readFileSync(stateFile, "utf-8");
+  return content + `
+
+---
+## Project State
+\`\`\`json
+${stateContent}
+\`\`\`
+`;
+}
 function createRunCommand2() {
   return new Command22("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Complexity: auto, light, full", "auto").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts, _cmd) => {
     const skillsDir = resolveSkillsDir();
@@ -2175,64 +2315,24 @@ function createRunCommand2() {
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path16.join(skillDir, "skill.yaml");
-    let metadata = null;
-    if (fs7.existsSync(yamlPath)) {
-      try {
-        const raw = fs7.readFileSync(yamlPath, "utf-8");
-        const parsed = parse2(raw);
-        const result = SkillMetadataSchema.safeParse(parsed);
-        if (result.success) metadata = result.data;
-      } catch {
-      }
-    }
-    let complexity;
-    if (metadata?.phases && metadata.phases.length > 0) {
-      const requested = opts.complexity ?? "auto";
-      if (requested === "auto") {
-        const projectPath2 = opts.path ? path16.resolve(opts.path) : process.cwd();
-        complexity = detectComplexity(projectPath2);
-      } else {
-        complexity = requested;
-      }
-    }
-    let principles;
+    const metadata = loadSkillMetadata(skillDir);
     const projectPath = opts.path ? path16.resolve(opts.path) : process.cwd();
-    const principlesPath = path16.join(projectPath, "docs", "principles.md");
-    if (fs7.existsSync(principlesPath)) {
-      principles = fs7.readFileSync(principlesPath, "utf-8");
-    }
+    const complexity = resolveComplexity(
+      metadata,
+      opts.complexity ?? "auto",
+      projectPath
+    );
+    const principles = loadPrinciples(projectPath);
     let priorState;
     let stateWarning;
     if (opts.phase) {
-      if (metadata?.phases) {
-        const validPhases = metadata.phases.map((p) => p.name);
-        if (!validPhases.includes(opts.phase)) {
-          logger.error(`Unknown phase: ${opts.phase}. Valid phases: ${validPhases.join(", ")}`);
-          process.exit(ExitCode.ERROR);
-          return;
-        }
-      }
-      if (metadata?.state.persistent && metadata.state.files.length > 0) {
-        for (const stateFilePath of metadata.state.files) {
-          const fullPath = path16.join(projectPath, stateFilePath);
-          if (fs7.existsSync(fullPath)) {
-            const stat = fs7.statSync(fullPath);
-            if (stat.isDirectory()) {
-              const files = fs7.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs7.statSync(path16.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-              if (files.length > 0) {
-                priorState = fs7.readFileSync(path16.join(fullPath, files[0].name), "utf-8");
-              }
-            } else {
-              priorState = fs7.readFileSync(fullPath, "utf-8");
-            }
-            break;
-          }
-        }
-        if (!priorState) {
-          stateWarning = "No prior phase data found. Earlier phases have not been completed. Proceed with caution.";
-        }
+      const phaseResult = resolvePhaseState(metadata, projectPath, opts.phase);
+      if (!phaseResult) {
+        process.exit(ExitCode.ERROR);
+        return;
       }
+      priorState = phaseResult.priorState;
+      stateWarning = phaseResult.stateWarning;
     }
     const preamble = buildPreamble({
       ...complexity !== void 0 && { complexity },
@@ -2249,21 +2349,12 @@ function createRunCommand2() {
       process.exit(ExitCode.ERROR);
       return;
     }
-    let content = fs7.readFileSync(skillMdPath, "utf-8");
-    if (metadata?.state.persistent && opts.path) {
-      const stateFile = path16.join(projectPath, ".harness", "state.json");
-      if (fs7.existsSync(stateFile)) {
-        const stateContent = fs7.readFileSync(stateFile, "utf-8");
-        content += `
-
----
-## Project State
-\`\`\`json
-${stateContent}
-\`\`\`
-`;
-      }
-    }
+    const content = appendProjectState(
+      fs7.readFileSync(skillMdPath, "utf-8"),
+      metadata,
+      projectPath,
+      !!opts.path
+    );
     process.stdout.write(preamble + content);
     process.exit(ExitCode.SUCCESS);
   });
@@ -2281,6 +2372,48 @@ var REQUIRED_SECTIONS = [
   "## Success Criteria",
   "## Examples"
 ];
+function validateSkillMd(name, skillMdPath, skillType, errors) {
+  if (!fs8.existsSync(skillMdPath)) {
+    errors.push(`${name}: missing SKILL.md`);
+    return;
+  }
+  const mdContent = fs8.readFileSync(skillMdPath, "utf-8");
+  for (const section of REQUIRED_SECTIONS) {
+    if (!mdContent.includes(section)) {
+      errors.push(`${name}/SKILL.md: missing section "${section}"`);
+    }
+  }
+  if (!mdContent.trim().startsWith("# ")) {
+    errors.push(`${name}/SKILL.md: must start with an h1 heading`);
+  }
+  if (skillType === "rigid") {
+    if (!mdContent.includes("## Gates"))
+      errors.push(`${name}/SKILL.md: rigid skill missing "## Gates" section`);
+    if (!mdContent.includes("## Escalation"))
+      errors.push(`${name}/SKILL.md: rigid skill missing "## Escalation" section`);
+  }
+}
+function validateSkillEntry(name, skillsDir, errors) {
+  const skillDir = path17.join(skillsDir, name);
+  const yamlPath = path17.join(skillDir, "skill.yaml");
+  if (!fs8.existsSync(yamlPath)) {
+    errors.push(`${name}: missing skill.yaml`);
+    return false;
+  }
+  try {
+    const raw = fs8.readFileSync(yamlPath, "utf-8");
+    const result = SkillMetadataSchema.safeParse(parse3(raw));
+    if (!result.success) {
+      errors.push(`${name}/skill.yaml: ${result.error.message}`);
+      return false;
+    }
+    validateSkillMd(name, path17.join(skillDir, "SKILL.md"), result.data.type, errors);
+    return true;
+  } catch (e) {
+    errors.push(`${name}: parse error \u2014 ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+}
 function createValidateCommand3() {
   return new Command23("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -2294,46 +2427,7 @@ function createValidateCommand3() {
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path17.join(skillsDir, name);
-      const yamlPath = path17.join(skillDir, "skill.yaml");
-      const skillMdPath = path17.join(skillDir, "SKILL.md");
-      if (!fs8.existsSync(yamlPath)) {
-        errors.push(`${name}: missing skill.yaml`);
-        continue;
-      }
-      try {
-        const raw = fs8.readFileSync(yamlPath, "utf-8");
-        const parsed = parse3(raw);
-        const result = SkillMetadataSchema.safeParse(parsed);
-        if (!result.success) {
-          errors.push(`${name}/skill.yaml: ${result.error.message}`);
-          continue;
-        }
-        if (fs8.existsSync(skillMdPath)) {
-          const mdContent = fs8.readFileSync(skillMdPath, "utf-8");
-          for (const section of REQUIRED_SECTIONS) {
-            if (!mdContent.includes(section)) {
-              errors.push(`${name}/SKILL.md: missing section "${section}"`);
-            }
-          }
-          if (!mdContent.trim().startsWith("# ")) {
-            errors.push(`${name}/SKILL.md: must start with an h1 heading`);
-          }
-          if (result.data.type === "rigid") {
-            if (!mdContent.includes("## Gates")) {
-              errors.push(`${name}/SKILL.md: rigid skill missing "## Gates" section`);
-            }
-            if (!mdContent.includes("## Escalation")) {
-              errors.push(`${name}/SKILL.md: rigid skill missing "## Escalation" section`);
-            }
-          }
-        } else {
-          errors.push(`${name}: missing SKILL.md`);
-        }
-        validated++;
-      } catch (e) {
-        errors.push(`${name}: parse error \u2014 ${e instanceof Error ? e.message : String(e)}`);
-      }
+      if (validateSkillEntry(name, skillsDir, errors)) validated++;
     }
     if (globalOpts.json) {
       logger.raw({ validated, errors });
@@ -3031,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") {
@@ -3146,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",
@@ -3190,9 +3575,9 @@ 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 = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const mode = resolveOutputMode(globalOpts);
     const skip = parseSkip(opts.skip);
     const failOn = parseFailOn(opts.failOn);
     const result = await runCICheck({
@@ -3234,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",
@@ -3337,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;
@@ -3354,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 }));
@@ -3372,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];
@@ -3439,15 +4081,30 @@ 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());
     });
   });
 }
+async function offerRegeneration() {
+  console.log("");
+  const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (Y/n) ");
+  if (regenAnswer === "n" || regenAnswer === "no") return;
+  const scopeAnswer = await prompt("Generate for (G)lobal or (l)ocal project? (G/l) ");
+  const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
+  try {
+    execFileSync4("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+      stdio: "inherit"
+    });
+  } catch {
+    logger.warn("Generation failed. Run manually:");
+    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) {
@@ -3469,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("");
       }
     }
@@ -3496,31 +4153,18 @@ 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);
     }
-    console.log("");
-    const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (Y/n) ");
-    if (regenAnswer !== "n" && regenAnswer !== "no") {
-      const scopeAnswer = await prompt("Generate for (G)lobal or (l)ocal project? (G/l) ");
-      const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
-      try {
-        execFileSync4("harness", ["generate", ...isGlobal ? ["--global"] : []], {
-          stdio: "inherit"
-        });
-      } catch {
-        logger.warn("Generation failed. Run manually:");
-        console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
-      }
-    }
+    await offerRegeneration();
     process.exit(ExitCode.SUCCESS);
   });
 }
 
 // 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) {
@@ -3579,10 +4223,10 @@ 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-HXHWB7SV.js");
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-B26DFXMP.js");
   const store = new GraphStore();
   const start = Date.now();
   await new CodeIngestor(store).ingest(projectPath);
@@ -3593,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);
@@ -3618,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
     );
@@ -3663,8 +4307,8 @@ async function runIngest(projectPath, source, opts) {
     SyncManager,
     JiraConnector,
     SlackConnector
-  } = await import("./dist-HXHWB7SV.js");
-  const graphDir = path30.join(projectPath, ".harness", "graph");
+  } = await import("./dist-B26DFXMP.js");
+  const graphDir = path36.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -3725,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,
@@ -3753,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-HXHWB7SV.js");
+  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 = {
@@ -3772,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),
@@ -3800,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-HXHWB7SV.js");
-  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-B26DFXMP.js");
+  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 {
   }
@@ -3825,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;
     }
@@ -3843,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-HXHWB7SV.js");
-  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-B26DFXMP.js");
+  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.");
@@ -3875,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));
@@ -3908,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);
@@ -3921,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-JQUI7BVZ.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", {
@@ -3947,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;
   }
@@ -3956,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;
 }
@@ -4079,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";
@@ -4126,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,
@@ -4139,9 +4783,9 @@ 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 getCommitHash(cwd) {
+function getCommitHash2(cwd) {
   try {
     return execSync4("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
   } catch {
@@ -4189,7 +4833,7 @@ async function runCheckArch(options) {
   }
   const manager = new ArchBaselineManager(cwd, archConfig.baselinePath);
   if (options.updateBaseline) {
-    const commitHash = getCommitHash(cwd);
+    const commitHash = getCommitHash2(cwd);
     const baseline2 = manager.capture(results, commitHash);
     manager.save(baseline2);
     return Ok({
@@ -4234,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);
@@ -4300,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)}`
@@ -4324,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.`
@@ -4342,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(
@@ -4356,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);
@@ -4374,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}`);
@@ -4386,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(
@@ -4415,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) {
@@ -4463,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(", ")}`
@@ -4501,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(
@@ -4570,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(
@@ -4598,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);
@@ -4642,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);
@@ -4666,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}` };
@@ -4697,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.`
@@ -4717,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 {
@@ -4865,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);
@@ -4900,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);
@@ -4922,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);
@@ -4950,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 {
@@ -4987,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) {
@@ -5000,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,
@@ -5026,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) {
@@ -5064,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);
@@ -5083,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) {
@@ -5113,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);
@@ -5158,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());
@@ -5193,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());
@@ -5217,6 +5864,7 @@ function createProgram() {
 
 export {
   buildPreamble,
+  printFirstRunWelcome,
   runScan,
   runIngest,
   runQuery,