@harness-engineering/cli 1.14.0 → 1.16.0

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

@@ -6,11 +6,11 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-6KTUUFRN.js";
+} from "./chunk-5ZXHMCPL.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-RCWZBSK5.js";
+} from "./chunk-6KWBH4EO.js";
 import {
   listPersonas,
   loadPersona
@@ -20,13 +20,13 @@ import {
 } from "./chunk-TRAPF4IX.js";
 import {
   executeSkill
-} from "./chunk-AOZRDOIP.js";
+} from "./chunk-M6TIO6NF.js";
 import {
   ALLOWED_PERSONA_COMMANDS
 } from "./chunk-TEFCFC4H.js";
 import {
   createCreateSkillCommand
-} from "./chunk-YBJ262QL.js";
+} from "./chunk-LRG3B43J.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -50,14 +50,14 @@ import {
   handleGetImpact,
   handleOrphanDeletion,
   persistToolingConfig
-} from "./chunk-YZD2MRNQ.js";
+} from "./chunk-JOP2NDNB.js";
 import {
   VALID_PLATFORMS
-} from "./chunk-ZOAWBDWU.js";
+} from "./chunk-CJDVBBPB.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-O5OJVPL6.js";
+} from "./chunk-OCDDCGDE.js";
 import {
   resolveGlobalSkillsDir,
   resolvePersonasDir,
@@ -72,7 +72,7 @@ import {
 } from "./chunk-3WGJMBKH.js";
 import {
   SkillMetadataSchema
-} from "./chunk-XYLGHKG6.js";
+} from "./chunk-HKUX2X7O.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -96,6 +96,10 @@ import {
   archiveStream,
   buildSnapshot,
   checkDocCoverage,
+  checkTaint,
+  clearTaint,
+  computeOverallSeverity,
+  computeScanExitCode,
   createFixes,
   createStream,
   deepMergeConstraints,
@@ -107,8 +111,11 @@ import {
   extractBundle,
   generateSuggestions,
   listStreams,
+  listTaintedSessions,
   loadState,
   loadStreamIndex,
+  mapInjectionFindings,
+  mapSecurityFindings,
   parseDiff,
   parseManifest,
   parseSecurityConfig,
@@ -121,20 +128,21 @@ import {
   runAll,
   runCIChecks,
   runReviewPipeline,
+  scanForInjection,
   setActiveStream,
   validateAgentsMap,
   validateDependencies,
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-ABQHQ6I5.js";
+} from "./chunk-ALFKNAZW.js";
 import {
   Err,
   Ok
 } from "./chunk-ERS5EVUZ.js";
 
 // src/index.ts
-import { Command as Command55 } from "commander";
+import { Command as Command70 } from "commander";
 
 // src/commands/validate.ts
 import { Command } from "commander";
@@ -213,7 +221,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-WNJM6H2D.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-4Y6NHNK3.js");
       const cwd = process.cwd();
       const specsDir = path.join(cwd, "docs", "specs");
       const plansDir = path.join(cwd, "docs", "plans");
@@ -481,10 +489,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path4.resolve(cwd);
   let configData = {};
   try {
-    const fs23 = await import("fs");
+    const fs34 = await import("fs");
     const configPath = path4.join(projectRoot, "harness.config.json");
-    if (fs23.existsSync(configPath)) {
-      const raw = fs23.readFileSync(configPath, "utf-8");
+    if (fs34.existsSync(configPath)) {
+      const raw = fs34.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -570,7 +578,7 @@ function registerBenchCommand(perf) {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-HWXF2C3R.js");
+    const { BenchmarkRunner } = await import("./dist-4LPXJYVZ.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
@@ -638,7 +646,7 @@ function registerBaselinesCommands(perf) {
   baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-HWXF2C3R.js");
+    const { BenchmarkRunner } = await import("./dist-4LPXJYVZ.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -671,7 +679,7 @@ function registerReportCommand(perf) {
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-HWXF2C3R.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-4LPXJYVZ.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -852,33 +860,248 @@ function createCheckDocsCommand() {
 // src/commands/init.ts
 import { Command as Command8 } from "commander";
 import chalk2 from "chalk";
-import * as fs2 from "fs";
-import * as path8 from "path";
+import * as fs4 from "fs";
+import * as path10 from "path";
 
 // src/commands/setup-mcp.ts
 import { Command as Command7 } from "commander";
-import * as fs from "fs";
-import * as path7 from "path";
+import * as fs3 from "fs";
+import * as path9 from "path";
 import * as os from "os";
 import chalk from "chalk";
-var HARNESS_MCP_ENTRY = {
-  command: "harness-mcp"
-};
-function readJsonFile(filePath) {
+import * as clack from "@clack/prompts";
+
+// src/integrations/config.ts
+import * as fs from "fs";
+import * as path7 from "path";
+function readJsonSafe(filePath) {
   if (!fs.existsSync(filePath)) return null;
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8"));
   } catch {
-    fs.copyFileSync(filePath, filePath + ".bak");
     return null;
   }
 }
-function writeJsonFile(filePath, data) {
+function writeJson(filePath, data) {
   const dir = path7.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  const tmp = filePath + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  fs.renameSync(tmp, filePath);
+}
+function readMcpConfig(filePath) {
+  const config = readJsonSafe(filePath);
+  if (!config) return { mcpServers: {} };
+  if (!config.mcpServers) config.mcpServers = {};
+  return config;
+}
+function writeMcpEntry(filePath, name, entry) {
+  const config = readMcpConfig(filePath);
+  config.mcpServers[name] = entry;
+  writeJson(filePath, config);
+}
+function removeMcpEntry(filePath, name) {
+  if (!fs.existsSync(filePath)) return;
+  const config = readMcpConfig(filePath);
+  delete config.mcpServers[name];
+  writeJson(filePath, config);
+}
+function readIntegrationsConfig(configPath) {
+  const raw = readJsonSafe(configPath);
+  if (!raw || !raw.integrations) return { enabled: [], dismissed: [] };
+  const integ = raw.integrations;
+  return {
+    enabled: Array.isArray(integ.enabled) ? integ.enabled : [],
+    dismissed: Array.isArray(integ.dismissed) ? integ.dismissed : []
+  };
+}
+function writeIntegrationsConfig(configPath, integrations) {
+  const raw = readJsonSafe(configPath) ?? {};
+  raw.integrations = integrations;
+  writeJson(configPath, raw);
+}
+
+// src/integrations/toml.ts
+import * as fs2 from "fs";
+import * as path8 from "path";
+function writeTomlMcpEntry(filePath, name, entry) {
+  const dir = path8.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const existing = fs2.existsSync(filePath) ? fs2.readFileSync(filePath, "utf-8") : "";
+  const blockHeader = `[mcp_servers.${name}]`;
+  const newBlock = serializeTomlMcpBlock(name, entry);
+  let updated;
+  if (existing.includes(blockHeader)) {
+    updated = replaceTomlBlock(existing, blockHeader, newBlock);
+  } else {
+    const separator = existing.length > 0 && !existing.endsWith("\n\n") ? "\n" : "";
+    updated = existing + separator + newBlock;
+  }
+  const tmp = filePath + ".tmp";
+  fs2.writeFileSync(tmp, updated);
+  fs2.renameSync(tmp, filePath);
+}
+function serializeTomlMcpBlock(name, entry) {
+  const lines = [`[mcp_servers.${name}]`];
+  lines.push(`command = ${JSON.stringify(entry.command)}`);
+  if (entry.args !== void 0) {
+    const argsLiteral = "[" + entry.args.map((a) => JSON.stringify(a)).join(", ") + "]";
+    lines.push(`args = ${argsLiteral}`);
+  }
+  if (entry.enabled !== void 0) {
+    lines.push(`enabled = ${entry.enabled}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function replaceTomlBlock(content, blockHeader, newBlock) {
+  const lines = content.split("\n");
+  const startIdx = lines.findIndex((l) => l.trim() === blockHeader);
+  if (startIdx === -1) return content + newBlock;
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (lines[i]?.match(/^\[(?!\[)/)) {
+      endIdx = i;
+      break;
+    }
+  }
+  while (endIdx > startIdx + 1 && lines[endIdx - 1]?.trim() === "") {
+    endIdx--;
+  }
+  const newBlockLines = newBlock.trimEnd().split("\n");
+  const result = [
+    ...lines.slice(0, startIdx),
+    ...newBlockLines,
+    ...endIdx < lines.length ? ["", ...lines.slice(endIdx)] : []
+  ];
+  return result.join("\n") + (content.endsWith("\n") ? "\n" : "");
+}
+
+// src/commands/setup-mcp.ts
+var HARNESS_MCP_ENTRY = {
+  command: "harness-mcp"
+};
+var CURSOR_CURATED_TOOLS = [
+  "run_skill",
+  "validate_project",
+  "emit_interaction",
+  "check_docs",
+  "manage_roadmap",
+  "run_code_review",
+  "check_phase_gate",
+  "gather_context",
+  "find_context_for",
+  "get_impact",
+  "detect_entropy",
+  "run_security_scan",
+  "assess_project",
+  "manage_state",
+  "create_self_review",
+  "analyze_diff",
+  "request_peer_review",
+  "review_changes",
+  "check_dependencies",
+  "search_skills",
+  "code_search",
+  "code_outline",
+  "ask_graph",
+  "query_graph",
+  "detect_anomalies"
+];
+var ALL_MCP_TOOLS = [
+  "validate_project",
+  "check_dependencies",
+  "check_docs",
+  "detect_entropy",
+  "generate_linter",
+  "validate_linter_config",
+  "init_project",
+  "list_personas",
+  "generate_persona_artifacts",
+  "run_persona",
+  "add_component",
+  "run_agent_task",
+  "run_skill",
+  "manage_state",
+  "create_self_review",
+  "analyze_diff",
+  "request_peer_review",
+  "check_phase_gate",
+  "validate_cross_check",
+  "create_skill",
+  "generate_slash_commands",
+  "query_graph",
+  "search_similar",
+  "find_context_for",
+  "get_relationships",
+  "get_impact",
+  "ingest_source",
+  "generate_agent_definitions",
+  "run_security_scan",
+  "check_performance",
+  "get_perf_baselines",
+  "update_perf_baselines",
+  "get_critical_paths",
+  "list_streams",
+  "manage_roadmap",
+  "emit_interaction",
+  "run_code_review",
+  "gather_context",
+  "assess_project",
+  "review_changes",
+  "detect_anomalies",
+  "ask_graph",
+  "check_task_independence",
+  "predict_conflicts",
+  "detect_stale_constraints",
+  "search_skills",
+  "code_outline",
+  "code_search",
+  "code_unfold"
+];
+async function runCursorToolPicker() {
+  try {
+    const selected = await clack.multiselect({
+      message: "Select tools to register for Cursor (25 recommended; Cursor supports ~40 across all servers)",
+      options: ALL_MCP_TOOLS.map((tool) => {
+        const opt = { value: tool, label: tool };
+        if (CURSOR_CURATED_TOOLS.includes(tool)) opt.hint = "recommended";
+        return opt;
+      }),
+      initialValues: CURSOR_CURATED_TOOLS
+    });
+    if (clack.isCancel(selected)) {
+      return CURSOR_CURATED_TOOLS;
+    }
+    return selected;
+  } catch {
+    return CURSOR_CURATED_TOOLS;
+  }
+}
+function writeCursorMcpEntryWithTools(configPath, tools) {
+  writeMcpEntry(configPath, "harness", {
+    command: "harness",
+    args: ["mcp", "--tools", ...tools]
+  });
+}
+function readJsonFile(filePath) {
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+  } catch {
+    fs3.copyFileSync(filePath, filePath + ".bak");
+    return null;
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path9.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function configureMcpServer(configPath) {
   const config = readJsonFile(configPath) ?? {};
@@ -893,7 +1116,7 @@ function configureMcpServer(configPath) {
   return true;
 }
 function addGeminiTrustedFolder(cwd) {
-  const trustedPath = path7.join(os.homedir(), ".gemini", "trustedFolders.json");
+  const trustedPath = path9.join(os.homedir(), ".gemini", "trustedFolders.json");
   const folders = readJsonFile(trustedPath) ?? {};
   if (folders[cwd] === "TRUST_FOLDER") {
     return false;
@@ -907,7 +1130,7 @@ function setupMcp(cwd, client) {
   const skipped = [];
   let trustedFolder = false;
   if (client === "all" || client === "claude") {
-    const configPath = path7.join(cwd, ".mcp.json");
+    const configPath = path9.join(cwd, ".mcp.json");
     if (configureMcpServer(configPath)) {
       configured.push("Claude Code");
     } else {
@@ -915,7 +1138,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "gemini") {
-    const configPath = path7.join(cwd, ".gemini", "settings.json");
+    const configPath = path9.join(cwd, ".gemini", "settings.json");
     if (configureMcpServer(configPath)) {
       configured.push("Gemini CLI");
     } else {
@@ -923,44 +1146,96 @@ function setupMcp(cwd, client) {
     }
     trustedFolder = addGeminiTrustedFolder(cwd);
   }
+  if (client === "all" || client === "codex") {
+    const configPath = path9.join(cwd, ".codex", "config.toml");
+    const alreadyConfigured = (() => {
+      if (!fs3.existsSync(configPath)) return false;
+      const content = fs3.readFileSync(configPath, "utf-8");
+      return content.includes("[mcp_servers.harness]");
+    })();
+    if (alreadyConfigured) {
+      skipped.push("Codex CLI");
+    } else {
+      writeTomlMcpEntry(configPath, "harness", {
+        command: "harness",
+        args: ["mcp"],
+        enabled: true
+      });
+      configured.push("Codex CLI");
+    }
+  }
+  if (client === "all" || client === "cursor") {
+    const configPath = path9.join(cwd, ".cursor", "mcp.json");
+    const existing = readJsonFile(configPath);
+    if (existing?.mcpServers?.["harness"]) {
+      skipped.push("Cursor");
+    } else {
+      writeMcpEntry(configPath, "harness", { command: "harness", args: ["mcp"] });
+      configured.push("Cursor");
+    }
+  }
   return { configured, skipped, trustedFolder };
 }
+async function resolveCursorWithPicker(cwd, pick) {
+  const configured = [];
+  const skipped = [];
+  const cursorConfigPath = path9.join(cwd, ".cursor", "mcp.json");
+  const existing = readJsonFile(cursorConfigPath);
+  if (existing?.mcpServers?.["harness"] && !pick) {
+    skipped.push("Cursor");
+  } else {
+    const tools = pick ? await runCursorToolPicker() : CURSOR_CURATED_TOOLS;
+    writeCursorMcpEntryWithTools(cursorConfigPath, tools);
+    configured.push("Cursor");
+  }
+  return { configured, skipped };
+}
+function printMcpResult(configured, skipped, trustedFolder) {
+  console.log("");
+  if (configured.length > 0) {
+    logger.success("MCP server configured!");
+    console.log("");
+    for (const name of configured) {
+      console.log(`  ${chalk.green("+")} ${name}`);
+    }
+  }
+  if (trustedFolder) {
+    console.log("");
+    logger.info("Added project to Gemini trusted folders (~/.gemini/trustedFolders.json)");
+  }
+  if (skipped.length > 0) {
+    console.log("");
+    logger.info("Already configured:");
+    for (const name of skipped) {
+      console.log(`  ${chalk.dim("-")} ${name}`);
+    }
+  }
+  console.log("");
+  console.log(chalk.bold("The harness MCP server provides:"));
+  console.log(
+    `  - ${ALL_MCP_TOOLS.length} tools for validation, entropy detection, skill execution, graph querying, and more`
+  );
+  console.log(
+    "  - 8 resources for project context, skills, rules, learnings, state, and graph data"
+  );
+  console.log("");
+  console.log(`Run ${chalk.cyan("harness skill list")} to see available skills.`);
+  console.log("");
+}
 function createSetupMcpCommand() {
-  return new Command7("setup-mcp").description("Configure MCP server for AI agent integration").option("--client <client>", "Client to configure (claude, gemini, all)", "all").action(async (opts, cmd) => {
+  return new Command7("setup-mcp").description("Configure MCP server for AI agent integration").option("--client <client>", "Client to configure (claude, gemini, codex, cursor, all)", "all").option("--pick", "Launch interactive tool picker (Cursor only)").option("--yes", "Bypass interactive picker and use curated 25-tool set (Cursor only)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { configured, skipped, trustedFolder } = setupMcp(cwd, opts.client);
+    let configured;
+    let skipped;
+    let trustedFolder = false;
+    if (opts.client === "cursor" && (opts.pick || opts.yes)) {
+      ({ configured, skipped } = await resolveCursorWithPicker(cwd, opts.pick));
+    } else {
+      ({ configured, skipped, trustedFolder } = setupMcp(cwd, opts.client));
+    }
     if (!globalOpts.quiet) {
-      console.log("");
-      if (configured.length > 0) {
-        logger.success("MCP server configured!");
-        console.log("");
-        for (const name of configured) {
-          console.log(`  ${chalk.green("+")} ${name}`);
-        }
-      }
-      if (trustedFolder) {
-        console.log("");
-        logger.info("Added project to Gemini trusted folders (~/.gemini/trustedFolders.json)");
-      }
-      if (skipped.length > 0) {
-        console.log("");
-        logger.info("Already configured:");
-        for (const name of skipped) {
-          console.log(`  ${chalk.dim("-")} ${name}`);
-        }
-      }
-      console.log("");
-      console.log(chalk.bold("The harness MCP server provides:"));
-      console.log(
-        "  - 31 tools for validation, entropy detection, skill execution, graph querying, and more"
-      );
-      console.log(
-        "  - 8 resources for project context, skills, rules, learnings, state, and graph data"
-      );
-      console.log("");
-      console.log(`Run ${chalk.cyan("harness skill list")} to see available skills.`);
-      console.log("");
+      printMcpResult(configured, skipped, trustedFolder);
     }
     process.exit(ExitCode.SUCCESS);
   });
@@ -969,10 +1244,10 @@ function createSetupMcpCommand() {
 // src/commands/init.ts
 async function runInit(options) {
   const cwd = options.cwd ?? process.cwd();
-  const name = options.name ?? path8.basename(cwd);
+  const name = options.name ?? path10.basename(cwd);
   const force = options.force ?? false;
-  const configPath = path8.join(cwd, "harness.config.json");
-  if (!force && fs2.existsSync(configPath)) {
+  const configPath = path10.join(cwd, "harness.config.json");
+  if (!force && fs4.existsSync(configPath)) {
     return Err(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
@@ -1090,7 +1365,7 @@ function createInitCommand() {
 
 // src/commands/cleanup.ts
 import { Command as Command9 } from "commander";
-import * as path9 from "path";
+import * as path11 from "path";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
@@ -1105,11 +1380,11 @@ async function runCleanup(options) {
     patternViolations: [],
     totalIssues: 0
   };
-  const rootDir = path9.resolve(cwd, config.rootDir);
-  const docsDir = path9.resolve(cwd, config.docsDir);
+  const rootDir = path11.resolve(cwd, config.rootDir);
+  const docsDir = path11.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path9.join(rootDir, "src/index.ts")],
+    entryPoints: [path11.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: type === "all" || type === "drift",
@@ -1209,7 +1484,7 @@ function createCleanupCommand() {
 
 // src/commands/fix-drift.ts
 import { Command as Command10 } from "commander";
-import * as path10 from "path";
+import * as path12 from "path";
 async function runFixDrift(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun !== false;
@@ -1218,11 +1493,11 @@ async function runFixDrift(options) {
     return Err(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path10.resolve(cwd, config.rootDir);
-  const docsDir = path10.resolve(cwd, config.docsDir);
+  const rootDir = path12.resolve(cwd, config.rootDir);
+  const docsDir = path12.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path10.join(rootDir, "src/index.ts")],
+    entryPoints: [path12.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: true,
@@ -1375,7 +1650,7 @@ import { Command as Command13 } from "commander";
 
 // src/commands/agent/run.ts
 import { Command as Command11 } from "commander";
-import * as path11 from "path";
+import * as path13 from "path";
 import * as childProcess from "child_process";
 async function runAgentTask(task, options) {
   const configResult = resolveConfig(options.configPath);
@@ -1447,7 +1722,7 @@ function createCommandExecutor() {
 }
 async function runPersonaMode(opts, quiet) {
   const personasDir = resolvePersonasDir();
-  const filePath = path11.join(personasDir, `${opts.persona}.yaml`);
+  const filePath = path13.join(personasDir, `${opts.persona}.yaml`);
   const personaResult = loadPersona(filePath);
   if (!personaResult.ok) {
     logger.error(personaResult.error.message);
@@ -1619,8 +1894,8 @@ function createAgentCommand() {
 
 // src/commands/add.ts
 import { Command as Command14 } from "commander";
-import * as fs3 from "fs";
-import * as path12 from "path";
+import * as fs5 from "fs";
+import * as path14 from "path";
 var LAYER_INDEX_TEMPLATE = (name) => `// ${name} layer
 // Add your ${name} exports here
 
@@ -1664,62 +1939,62 @@ async function runAdd(componentType, name, options) {
   try {
     switch (componentType) {
       case "layer": {
-        const layerDir = path12.join(cwd, "src", name);
-        if (!fs3.existsSync(layerDir)) {
-          fs3.mkdirSync(layerDir, { recursive: true });
+        const layerDir = path14.join(cwd, "src", name);
+        if (!fs5.existsSync(layerDir)) {
+          fs5.mkdirSync(layerDir, { recursive: true });
           created.push(`src/${name}/`);
         }
-        const indexPath = path12.join(layerDir, "index.ts");
-        if (!fs3.existsSync(indexPath)) {
-          fs3.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
+        const indexPath = path14.join(layerDir, "index.ts");
+        if (!fs5.existsSync(indexPath)) {
+          fs5.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
           created.push(`src/${name}/index.ts`);
         }
         break;
       }
       case "module": {
-        const modulePath = path12.join(cwd, "src", `${name}.ts`);
-        if (fs3.existsSync(modulePath)) {
+        const modulePath = path14.join(cwd, "src", `${name}.ts`);
+        if (fs5.existsSync(modulePath)) {
           return Err(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
         }
-        fs3.writeFileSync(modulePath, MODULE_TEMPLATE(name));
+        fs5.writeFileSync(modulePath, MODULE_TEMPLATE(name));
         created.push(`src/${name}.ts`);
         break;
       }
       case "doc": {
         const configDocsDir = configResult.ok ? configResult.value.docsDir : "./docs";
-        const docsDir = path12.resolve(cwd, configDocsDir);
-        if (!fs3.existsSync(docsDir)) {
-          fs3.mkdirSync(docsDir, { recursive: true });
+        const docsDir = path14.resolve(cwd, configDocsDir);
+        if (!fs5.existsSync(docsDir)) {
+          fs5.mkdirSync(docsDir, { recursive: true });
         }
-        const docPath = path12.join(docsDir, `${name}.md`);
-        if (fs3.existsSync(docPath)) {
+        const docPath = path14.join(docsDir, `${name}.md`);
+        if (fs5.existsSync(docPath)) {
           return Err(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
         }
-        fs3.writeFileSync(docPath, DOC_TEMPLATE(name));
+        fs5.writeFileSync(docPath, DOC_TEMPLATE(name));
         created.push(`${configDocsDir.replace(/^\.[\\/]/, "")}/${name}.md`);
         break;
       }
       case "skill": {
-        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-XSWHMSM5.js");
+        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-NDXQSTIK.js");
         generateSkillFiles2({
           name,
           description: `${name} skill`,
-          outputDir: path12.join(cwd, "agents", "skills", "claude-code")
+          outputDir: path14.join(cwd, "agents", "skills", "claude-code")
         });
         created.push(`agents/skills/claude-code/${name}/skill.yaml`);
         created.push(`agents/skills/claude-code/${name}/SKILL.md`);
         break;
       }
       case "persona": {
-        const personasDir = path12.join(cwd, "agents", "personas");
-        if (!fs3.existsSync(personasDir)) {
-          fs3.mkdirSync(personasDir, { recursive: true });
+        const personasDir = path14.join(cwd, "agents", "personas");
+        if (!fs5.existsSync(personasDir)) {
+          fs5.mkdirSync(personasDir, { recursive: true });
         }
-        const personaPath = path12.join(personasDir, `${name}.yaml`);
-        if (fs3.existsSync(personaPath)) {
+        const personaPath = path14.join(personasDir, `${name}.yaml`);
+        if (fs5.existsSync(personaPath)) {
           return Err(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
         }
-        fs3.writeFileSync(
+        fs5.writeFileSync(
           personaPath,
           `name: ${name}
 description: ${name} persona
@@ -1905,46 +2180,46 @@ function createListCommand() {
 
 // src/commands/persona/generate.ts
 import { Command as Command19 } from "commander";
-import * as fs4 from "fs";
-import * as path13 from "path";
+import * as fs6 from "fs";
+import * as path15 from "path";
 function createGenerateCommand2() {
   return new Command19("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
-    const filePath = path13.join(personasDir, `${name}.yaml`);
+    const filePath = path15.join(personasDir, `${name}.yaml`);
     const personaResult = loadPersona(filePath);
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const persona = personaResult.value;
-    const outputDir = path13.resolve(opts.outputDir);
+    const outputDir = path15.resolve(opts.outputDir);
     const slug = toKebabCase(persona.name);
     const only = opts.only;
     const generated = [];
     if (!only || only === "runtime") {
       const result = generateRuntime(persona);
       if (result.ok) {
-        const outPath = path13.join(outputDir, `${slug}.runtime.json`);
-        fs4.mkdirSync(path13.dirname(outPath), { recursive: true });
-        fs4.writeFileSync(outPath, result.value);
+        const outPath = path15.join(outputDir, `${slug}.runtime.json`);
+        fs6.mkdirSync(path15.dirname(outPath), { recursive: true });
+        fs6.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "agents-md") {
       const result = generateAgentsMd(persona);
       if (result.ok) {
-        const outPath = path13.join(outputDir, `${slug}.agents.md`);
-        fs4.writeFileSync(outPath, result.value);
+        const outPath = path15.join(outputDir, `${slug}.agents.md`);
+        fs6.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "ci") {
       const result = generateCIWorkflow(persona, "github");
       if (result.ok) {
-        const outPath = path13.join(outputDir, ".github", "workflows", `${slug}.yml`);
-        fs4.mkdirSync(path13.dirname(outPath), { recursive: true });
-        fs4.writeFileSync(outPath, result.value);
+        const outPath = path15.join(outputDir, ".github", "workflows", `${slug}.yml`);
+        fs6.mkdirSync(path15.dirname(outPath), { recursive: true });
+        fs6.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
@@ -1969,13 +2244,13 @@ import { Command as Command28 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command21 } from "commander";
-import * as fs6 from "fs";
-import * as path15 from "path";
+import * as fs8 from "fs";
+import * as path17 from "path";
 import { parse } from "yaml";
 
 // src/registry/lockfile.ts
-import * as fs5 from "fs";
-import * as path14 from "path";
+import * as fs7 from "fs";
+import * as path16 from "path";
 function createEmptyLockfile() {
   return { version: 1, skills: {} };
 }
@@ -1995,10 +2270,10 @@ function sortedStringify(obj) {
   );
 }
 function readLockfile2(filePath) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     return createEmptyLockfile();
   }
-  const raw = fs5.readFileSync(filePath, "utf-8");
+  const raw = fs7.readFileSync(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -2015,9 +2290,9 @@ function readLockfile2(filePath) {
   return parsed;
 }
 function writeLockfile2(filePath, lockfile) {
-  const dir = path14.dirname(filePath);
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
+  const dir = path16.dirname(filePath);
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
 }
 function updateLockfileEntry(lockfile, name, entry) {
   return {
@@ -2041,14 +2316,14 @@ function removeLockfileEntry(lockfile, name) {
 
 // src/commands/skill/list.ts
 function scanDirectory(dirPath, source) {
-  if (!fs6.existsSync(dirPath)) return [];
-  const entries = fs6.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs8.existsSync(dirPath)) return [];
+  const entries = fs8.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path15.join(dirPath, name, "skill.yaml");
-    if (!fs6.existsSync(yamlPath)) continue;
+    const yamlPath = path17.join(dirPath, name, "skill.yaml");
+    if (!fs8.existsSync(yamlPath)) continue;
     try {
-      const raw = fs6.readFileSync(yamlPath, "utf-8");
+      const raw = fs8.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -2066,10 +2341,10 @@ function scanDirectory(dirPath, source) {
 }
 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 skillsDir = path17.dirname(globalDir);
+  const communityBase = path17.join(skillsDir, "community");
+  const communityPlatformDir = path17.join(communityBase, "claude-code");
+  const lockfilePath = path17.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -2155,20 +2430,20 @@ function createListCommand2() {
 
 // src/commands/skill/run.ts
 import { Command as Command22 } from "commander";
-import * as fs7 from "fs";
-import * as path16 from "path";
+import * as fs9 from "fs";
+import * as path18 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
 import { execFileSync as execFileSync2 } from "child_process";
 function evaluateSignals(signals) {
-  if (signals.fileCount >= 3) return "full";
-  if (signals.newDir) return "full";
-  if (signals.newDep) return "full";
-  if (signals.fileCount <= 1) return "light";
-  if (signals.testOnly) return "light";
-  if (signals.docsOnly) return "light";
-  return "full";
+  if (signals.fileCount >= 3) return "thorough";
+  if (signals.newDir) return "thorough";
+  if (signals.newDep) return "thorough";
+  if (signals.fileCount <= 1) return "fast";
+  if (signals.testOnly) return "fast";
+  if (signals.docsOnly) return "fast";
+  return "thorough";
 }
 function detectComplexity(projectPath) {
   try {
@@ -2201,7 +2476,7 @@ function detectComplexity(projectPath) {
     };
     return evaluateSignals(signals);
   } catch {
-    return "full";
+    return "thorough";
   }
 }
 
@@ -2211,8 +2486,8 @@ function buildPreamble(options) {
   if (options.complexity && options.phases && options.phases.length > 0) {
     const lines = [`## Active Phases (complexity: ${options.complexity})`];
     for (const phase of options.phases) {
-      if (options.complexity === "light" && !phase.required) {
-        lines.push(`- ~~${phase.name.toUpperCase()}~~ (skipped in light mode)`);
+      if (options.complexity === "fast" && !phase.required) {
+        lines.push(`- ~~${phase.name.toUpperCase()}~~ (skipped in fast mode)`);
       } else {
         lines.push(`- ${phase.name.toUpperCase()} (${phase.required ? "required" : "optional"})`);
       }
@@ -2244,10 +2519,10 @@ ${options.priorState}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path16.join(skillDir, "skill.yaml");
-  if (!fs7.existsSync(yamlPath)) return null;
+  const yamlPath = path18.join(skillDir, "skill.yaml");
+  if (!fs9.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs7.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs9.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -2255,26 +2530,26 @@ function loadSkillMetadata(skillDir) {
 }
 function resolveComplexity(metadata, requested, projectPath) {
   if (!metadata?.phases || metadata.phases.length === 0) return void 0;
-  if (requested === "auto") return detectComplexity(projectPath);
+  if (requested === "standard") 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;
+  const principlesPath = path18.join(projectPath, "docs", "principles.md");
+  return fs9.existsSync(principlesPath) ? fs9.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");
+  const files = fs9.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs9.statSync(path18.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs9.readFileSync(path18.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);
+    const fullPath = path18.join(projectPath, stateFilePath);
+    if (!fs9.existsSync(fullPath)) continue;
+    const stat = fs9.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs7.readFileSync(fullPath, "utf-8");
+    return fs9.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -2294,9 +2569,9 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 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");
+  const stateFile = path18.join(projectPath, ".harness", "state.json");
+  if (!fs9.existsSync(stateFile)) return content;
+  const stateContent = fs9.readFileSync(stateFile, "utf-8");
   return content + `
 
 ---
@@ -2307,19 +2582,19 @@ ${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) => {
+  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>", "Rigor level: fast, standard, thorough", "standard").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();
-    const skillDir = path16.join(skillsDir, name);
-    if (!fs7.existsSync(skillDir)) {
+    const skillDir = path18.join(skillsDir, name);
+    if (!fs9.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     const metadata = loadSkillMetadata(skillDir);
-    const projectPath = opts.path ? path16.resolve(opts.path) : process.cwd();
+    const projectPath = opts.path ? path18.resolve(opts.path) : process.cwd();
     const complexity = resolveComplexity(
       metadata,
-      opts.complexity ?? "auto",
+      opts.complexity ?? "standard",
       projectPath
     );
     const principles = loadPrinciples(projectPath);
@@ -2343,14 +2618,14 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path16.join(skillDir, "SKILL.md");
-    if (!fs7.existsSync(skillMdPath)) {
+    const skillMdPath = path18.join(skillDir, "SKILL.md");
+    if (!fs9.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     const content = appendProjectState(
-      fs7.readFileSync(skillMdPath, "utf-8"),
+      fs9.readFileSync(skillMdPath, "utf-8"),
       metadata,
       projectPath,
       !!opts.path
@@ -2362,8 +2637,8 @@ function createRunCommand2() {
 
 // src/commands/skill/validate.ts
 import { Command as Command23 } from "commander";
-import * as fs8 from "fs";
-import * as path17 from "path";
+import * as fs10 from "fs";
+import * as path19 from "path";
 import { parse as parse3 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
@@ -2373,11 +2648,11 @@ var REQUIRED_SECTIONS = [
   "## Examples"
 ];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs8.existsSync(skillMdPath)) {
+  if (!fs10.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs8.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs10.readFileSync(skillMdPath, "utf-8");
   for (const section of REQUIRED_SECTIONS) {
     if (!mdContent.includes(section)) {
       errors.push(`${name}/SKILL.md: missing section "${section}"`);
@@ -2394,20 +2669,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path17.join(skillsDir, name);
-  const yamlPath = path17.join(skillDir, "skill.yaml");
-  if (!fs8.existsSync(yamlPath)) {
+  const skillDir = path19.join(skillsDir, name);
+  const yamlPath = path19.join(skillDir, "skill.yaml");
+  if (!fs10.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs8.readFileSync(yamlPath, "utf-8");
+    const raw = fs10.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);
+    validateSkillMd(name, path19.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)}`);
@@ -2418,12 +2693,12 @@ function createValidateCommand3() {
   return new Command23("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs8.existsSync(skillsDir)) {
+    if (!fs10.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs10.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -2446,27 +2721,27 @@ function createValidateCommand3() {
 
 // src/commands/skill/info.ts
 import { Command as Command24 } from "commander";
-import * as fs9 from "fs";
-import * as path18 from "path";
+import * as fs11 from "fs";
+import * as path20 from "path";
 import { parse as parse4 } from "yaml";
 function createInfoCommand() {
   return new Command24("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    const skillDir = path18.join(skillsDir, name);
-    if (!fs9.existsSync(skillDir)) {
+    const skillDir = path20.join(skillsDir, name);
+    if (!fs11.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path18.join(skillDir, "skill.yaml");
-    if (!fs9.existsSync(yamlPath)) {
+    const yamlPath = path20.join(skillDir, "skill.yaml");
+    if (!fs11.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     try {
-      const raw = fs9.readFileSync(yamlPath, "utf-8");
+      const raw = fs11.readFileSync(yamlPath, "utf-8");
       const parsed = parse4(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
@@ -2509,8 +2784,8 @@ function createInfoCommand() {
 import { Command as Command25 } from "commander";
 
 // src/registry/npm-client.ts
-import * as fs10 from "fs";
-import * as path19 from "path";
+import * as fs12 from "fs";
+import * as path21 from "path";
 import * as os2 from "os";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 var FETCH_TIMEOUT_MS = 3e4;
@@ -2533,10 +2808,10 @@ function extractSkillName(packageName) {
 function readNpmrcToken(registryUrl) {
   const { hostname, pathname } = new URL(registryUrl);
   const registryPath = `//${hostname}${pathname.replace(/\/$/, "")}/:_authToken=`;
-  const candidates = [path19.join(process.cwd(), ".npmrc"), path19.join(os2.homedir(), ".npmrc")];
+  const candidates = [path21.join(process.cwd(), ".npmrc"), path21.join(os2.homedir(), ".npmrc")];
   for (const npmrcPath of candidates) {
     try {
-      const content = fs10.readFileSync(npmrcPath, "utf-8");
+      const content = fs12.readFileSync(npmrcPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (trimmed.startsWith(registryPath)) {
@@ -2681,8 +2956,8 @@ Found ${results.length} skill(s):
 
 // src/commands/skill/create.ts
 import { Command as Command26 } from "commander";
-import * as path20 from "path";
-import * as fs11 from "fs";
+import * as path22 from "path";
+import * as fs13 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -2766,22 +3041,22 @@ function runCreate(name, opts) {
   if (!KEBAB_CASE_RE.test(name)) {
     throw new Error(`Invalid skill name "${name}". Must be kebab-case (e.g., my-skill).`);
   }
-  const baseDir = opts.outputDir ?? path20.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path20.join(baseDir, name);
-  if (fs11.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path22.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path22.join(baseDir, name);
+  if (fs13.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs11.mkdirSync(skillDir, { recursive: true });
+  fs13.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path20.join(skillDir, "skill.yaml");
-  fs11.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path22.join(skillDir, "skill.yaml");
+  fs13.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path20.join(skillDir, "SKILL.md");
-  fs11.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path22.join(skillDir, "SKILL.md");
+  fs13.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path20.join(skillDir, "README.md");
-  fs11.writeFileSync(readmePath, readme);
+  const readmePath = path22.join(skillDir, "README.md");
+  fs13.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -2809,7 +3084,7 @@ function createCreateCommand() {
         logger.info(`
 Next steps:`);
         logger.info(
-          `  1. Edit ${path20.join(result.directory, "SKILL.md")} with your skill content`
+          `  1. Edit ${path22.join(result.directory, "SKILL.md")} with your skill content`
         );
         logger.info(`  2. Run: harness skill validate ${name}`);
         logger.info(`  3. Run: harness skills publish`);
@@ -2823,28 +3098,28 @@ Next steps:`);
 
 // src/commands/skill/publish.ts
 import { Command as Command27 } from "commander";
-import * as fs14 from "fs";
-import * as path23 from "path";
+import * as fs16 from "fs";
+import * as path25 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs13 from "fs";
-import * as path22 from "path";
+import * as fs15 from "fs";
+import * as path24 from "path";
 import { parse as parse5 } from "yaml";
 import semver from "semver";
 
 // src/registry/bundled-skills.ts
-import * as fs12 from "fs";
-import * as path21 from "path";
+import * as fs14 from "fs";
+import * as path23 from "path";
 function getBundledSkillNames(bundledSkillsDir) {
-  if (!fs12.existsSync(bundledSkillsDir)) {
+  if (!fs14.existsSync(bundledSkillsDir)) {
     return /* @__PURE__ */ new Set();
   }
-  const entries = fs12.readdirSync(bundledSkillsDir);
+  const entries = fs14.readdirSync(bundledSkillsDir);
   const names = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     try {
-      const stat = fs12.statSync(path21.join(bundledSkillsDir, String(entry)));
+      const stat = fs14.statSync(path23.join(bundledSkillsDir, String(entry)));
       if (stat.isDirectory()) {
         names.add(String(entry));
       }
@@ -2857,14 +3132,14 @@ function getBundledSkillNames(bundledSkillsDir) {
 // src/registry/validator.ts
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path22.join(skillDir, "skill.yaml");
-  if (!fs13.existsSync(skillYamlPath)) {
+  const skillYamlPath = path24.join(skillDir, "skill.yaml");
+  if (!fs15.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs13.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs15.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -2886,11 +3161,11 @@ async function validateForPublish(skillDir, registryUrl) {
   if (!skillMeta.triggers || skillMeta.triggers.length === 0) {
     errors.push("At least one trigger is required. Add triggers to skill.yaml.");
   }
-  const skillMdPath = path22.join(skillDir, "SKILL.md");
-  if (!fs13.existsSync(skillMdPath)) {
+  const skillMdPath = path24.join(skillDir, "SKILL.md");
+  if (!fs15.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs13.readFileSync(skillMdPath, "utf-8");
+    const content = fs15.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -2970,11 +3245,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path23.join(skillDir, "package.json");
-  fs14.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path23.join(skillDir, "README.md");
-  if (!fs14.existsSync(readmePath)) {
-    const skillMdContent = fs14.readFileSync(path23.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path25.join(skillDir, "package.json");
+  fs16.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path25.join(skillDir, "README.md");
+  if (!fs16.existsSync(readmePath)) {
+    const skillMdContent = fs16.readFileSync(path25.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -2988,7 +3263,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs14.writeFileSync(readmePath, readme);
+    fs16.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -3055,11 +3330,11 @@ import { Command as Command33 } from "commander";
 
 // src/commands/state/show.ts
 import { Command as Command29 } from "commander";
-import * as path24 from "path";
+import * as path26 from "path";
 function createShowCommand() {
   return new Command29("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path24.resolve(opts.path);
+    const projectPath = path26.resolve(opts.path);
     const result = await loadState(projectPath, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3100,12 +3375,12 @@ Decisions: ${state.decisions.length}`);
 
 // src/commands/state/reset.ts
 import { Command as Command30 } from "commander";
-import * as fs15 from "fs";
-import * as path25 from "path";
+import * as fs17 from "fs";
+import * as path27 from "path";
 import * as readline from "readline";
 function createResetCommand() {
   return new Command30("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
-    const projectPath = path25.resolve(opts.path);
+    const projectPath = path27.resolve(opts.path);
     let statePath;
     if (opts.stream) {
       const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
@@ -3114,19 +3389,19 @@ function createResetCommand() {
         process.exit(ExitCode.ERROR);
         return;
       }
-      statePath = path25.join(streamResult.value, "state.json");
+      statePath = path27.join(streamResult.value, "state.json");
     } else {
-      statePath = path25.join(projectPath, ".harness", "state.json");
+      statePath = path27.join(projectPath, ".harness", "state.json");
     }
-    if (!fs15.existsSync(statePath)) {
+    if (!fs17.existsSync(statePath)) {
       logger.info("No state file found. Nothing to reset.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
     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((resolve31) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve31);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -3136,7 +3411,7 @@ function createResetCommand() {
       }
     }
     try {
-      fs15.unlinkSync(statePath);
+      fs17.unlinkSync(statePath);
       logger.success("Project state reset.");
     } catch (e) {
       logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -3149,10 +3424,10 @@ function createResetCommand() {
 
 // src/commands/state/learn.ts
 import { Command as Command31 } from "commander";
-import * as path26 from "path";
+import * as path28 from "path";
 function createLearnCommand() {
   return new Command31("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
-    const projectPath = path26.resolve(opts.path);
+    const projectPath = path28.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3166,12 +3441,12 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 import { Command as Command32 } from "commander";
-import * as path27 from "path";
+import * as path29 from "path";
 function createStreamsCommand() {
   const command = new Command32("streams").description("Manage state streams");
   command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path29.resolve(opts.path);
     const indexResult = await loadStreamIndex(projectPath);
     const result = await listStreams(projectPath);
     if (!result.ok) {
@@ -3195,7 +3470,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path29.resolve(opts.path);
     const result = await createStream(projectPath, name, opts.branch);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3206,7 +3481,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path29.resolve(opts.path);
     const result = await archiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3217,7 +3492,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path29.resolve(opts.path);
     const result = await setActiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3240,59 +3515,518 @@ function createStateCommand() {
   return command;
 }
 
-// src/commands/ci/index.ts
-import { Command as Command36 } from "commander";
-
-// src/commands/ci/check.ts
+// src/commands/setup.ts
 import { Command as Command34 } from "commander";
-var VALID_CHECKS = [
-  "validate",
-  "deps",
-  "docs",
-  "entropy",
-  "security",
-  "perf",
-  "phase-gate",
-  "arch"
-];
-async function runCICheck(options) {
-  const configResult = resolveConfig(options.configPath);
-  if (!configResult.ok) {
-    return configResult;
+import * as fs19 from "fs";
+import * as os4 from "os";
+import * as path31 from "path";
+import chalk3 from "chalk";
+
+// src/utils/first-run.ts
+import * as fs18 from "fs";
+import * as os3 from "os";
+import * as path30 from "path";
+var HARNESS_DIR = path30.join(os3.homedir(), ".harness");
+var MARKER_FILE = path30.join(HARNESS_DIR, ".setup-complete");
+function isFirstRun() {
+  return !fs18.existsSync(MARKER_FILE);
+}
+function markSetupComplete() {
+  fs18.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs18.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 {
   }
-  const input = {
-    projectRoot: process.cwd(),
-    config: configResult.value
+}
+
+// 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"
   };
-  if (options.skip) input.skip = options.skip;
-  if (options.failOn) input.failOn = options.failOn;
-  const result = await runCIChecks(input);
-  if (!result.ok) {
-    return {
-      ok: false,
-      error: new CLIError(result.error.message, ExitCode.ERROR)
-    };
+}
+
+// src/integrations/registry.ts
+var INTEGRATION_REGISTRY = [
+  // --- Tier 0: zero-config (free, no API key) ---
+  {
+    name: "context7",
+    displayName: "Context7",
+    description: "Live version-pinned docs for 9,000+ libraries",
+    tier: 0,
+    mcpConfig: {
+      command: "npx",
+      args: ["-y", "@upstash/context7-mcp"]
+    },
+    platforms: ["claude-code", "gemini-cli"]
+  },
+  {
+    name: "sequential-thinking",
+    displayName: "Sequential Thinking",
+    description: "Structured multi-step reasoning",
+    tier: 0,
+    mcpConfig: {
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-sequential-thinking"]
+    },
+    platforms: ["claude-code", "gemini-cli"]
+  },
+  {
+    name: "playwright",
+    displayName: "Playwright",
+    description: "Browser automation for E2E testing",
+    tier: 0,
+    mcpConfig: {
+      command: "npx",
+      args: ["-y", "@playwright/mcp"]
+    },
+    platforms: ["claude-code", "gemini-cli"]
+  },
+  // --- Tier 1: API-key required ---
+  {
+    name: "perplexity",
+    displayName: "Perplexity",
+    description: "Real-time web search and deep research",
+    tier: 1,
+    envVar: "PERPLEXITY_API_KEY",
+    mcpConfig: {
+      command: "npx",
+      args: ["-y", "perplexity-mcp"],
+      env: { PERPLEXITY_API_KEY: "${PERPLEXITY_API_KEY}" }
+      // harness-ignore SEC-SEC-002: env var placeholder, not a hardcoded secret
+    },
+    installHint: "Get an API key at https://perplexity.ai/settings/api",
+    platforms: ["claude-code", "gemini-cli"]
+  },
+  {
+    name: "augment-code",
+    displayName: "Augment Code",
+    description: "Semantic code search across codebase",
+    tier: 1,
+    envVar: "AUGMENT_SESSION_AUTH",
+    mcpConfig: {
+      command: "auggie",
+      args: ["--mcp", "--mcp-auto-workspace"],
+      env: { AUGMENT_SESSION_AUTH: "${AUGMENT_SESSION_AUTH}" }
+    },
+    installHint: "Install auggie CLI: npm i -g @augmentcode/auggie@latest && auggie login",
+    platforms: ["claude-code", "gemini-cli"]
   }
-  return { ok: true, value: result.value };
+];
+
+// 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 parseSkip(skip) {
-  if (!skip) return [];
-  return skip.split(",").map((s) => s.trim()).filter((s) => VALID_CHECKS.includes(s));
+function runSlashCommandGeneration() {
+  try {
+    const results = generateSlashCommands({
+      global: true,
+      platforms: ["claude-code", "gemini-cli", "codex", "cursor"],
+      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 parseFailOn(failOn) {
-  if (failOn === "warning") return "warning";
-  return "error";
+function detectClient(dirName) {
+  return fs19.existsSync(path31.join(os4.homedir(), dirName));
 }
-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) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const mode = resolveOutputMode(globalOpts);
-    const skip = parseSkip(opts.skip);
-    const failOn = parseFailOn(opts.failOn);
-    const result = await runCICheck({
-      configPath: globalOpts.config,
-      skip,
-      failOn
+async 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"
+    },
+    { name: "Codex CLI", dir: ".codex", client: "codex", configTarget: ".codex/config.toml" },
+    { name: "Cursor", dir: ".cursor", client: "cursor", configTarget: ".cursor/mcp.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 configureTier0Integrations(cwd) {
+  try {
+    const mcpPath = path31.join(cwd, ".mcp.json");
+    const config = readMcpConfig(mcpPath);
+    const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
+    const added = [];
+    for (const integration of tier0) {
+      if (config.mcpServers[integration.name]) continue;
+      writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
+      added.push(integration.displayName);
+    }
+    const geminiDir = path31.join(cwd, ".gemini");
+    if (fs19.existsSync(geminiDir)) {
+      const geminiPath = path31.join(geminiDir, "settings.json");
+      const geminiConfig = readMcpConfig(geminiPath);
+      for (const integration of tier0) {
+        if (!geminiConfig.mcpServers[integration.name]) {
+          writeMcpEntry(geminiPath, integration.name, integration.mcpConfig);
+        }
+      }
+    }
+    if (added.length === 0) {
+      return { status: "pass", message: "Tier 0 MCP integrations already configured" };
+    }
+    return {
+      status: "pass",
+      message: `Configured ${added.length} MCP integrations: ${added.join(", ")}`
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { status: "fail", message: `Tier 0 integration configuration failed \u2014 ${msg}` };
+  }
+}
+async 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 = await runMcpSetup(cwd);
+  steps.push(...mcpResults);
+  const tier0Result = configureTier0Integrations(cwd);
+  steps.push(tier0Result);
+  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(async () => {
+    const cwd = process.cwd();
+    console.log("");
+    console.log(`  ${chalk3.bold("harness setup")}`);
+    console.log("");
+    const { steps, success } = await 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 fs20 from "fs";
+import * as os5 from "os";
+import * as path32 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 fs20.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
+  } catch {
+    return 0;
+  }
+}
+function checkSlashCommands() {
+  const platforms = [
+    {
+      name: "Claude Code",
+      dir: path32.join(os5.homedir(), ".claude", "commands", "harness"),
+      ext: ".md",
+      client: "claude-code"
+    },
+    {
+      name: "Gemini CLI",
+      dir: path32.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 checkMcpConfig(cwd) {
+  const results = [];
+  const claudeConfig = readMcpConfig(path32.join(cwd, ".mcp.json"));
+  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 geminiDir = path32.join(cwd, ".gemini");
+  if (fs20.existsSync(geminiDir)) {
+    const geminiConfig = readMcpConfig(path32.join(geminiDir, "settings.json"));
+    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 loadMcpPresence(cwd) {
+  const mcpPath = path32.join(cwd, ".mcp.json");
+  const geminiDir = path32.join(cwd, ".gemini");
+  const hasGemini = fs20.existsSync(geminiDir);
+  return {
+    mcpConfig: readMcpConfig(mcpPath),
+    geminiConfig: hasGemini ? readMcpConfig(path32.join(geminiDir, "settings.json")) : null,
+    hasGemini
+  };
+}
+function checkTier0Presence(def, presence) {
+  const inClaude = !!presence.mcpConfig.mcpServers?.[def.name];
+  const inGemini = !!presence.geminiConfig?.mcpServers?.[def.name];
+  if (!inClaude) {
+    return {
+      name: `integration-${def.name}`,
+      status: "fail",
+      message: `${def.displayName} not configured. Run \`harness setup\` to fix.`,
+      fix: "Run: harness setup"
+    };
+  }
+  if (presence.hasGemini && !inGemini) {
+    return {
+      name: `integration-${def.name}`,
+      status: "warn",
+      message: `${def.displayName} missing from Gemini CLI config. Run \`harness setup\` to fix.`,
+      fix: "Run: harness setup"
+    };
+  }
+  return {
+    name: `integration-${def.name}`,
+    status: "pass",
+    message: `${def.displayName} configured`
+  };
+}
+function checkIntegrations(cwd) {
+  const results = [];
+  const presence = loadMcpPresence(cwd);
+  const configPath = path32.join(cwd, "harness.config.json");
+  const integrationsConfig = readIntegrationsConfig(configPath);
+  for (const def of INTEGRATION_REGISTRY.filter((d) => d.tier === 0)) {
+    results.push(checkTier0Presence(def, presence));
+  }
+  for (const def of INTEGRATION_REGISTRY.filter((d) => d.tier === 1)) {
+    const enabled = integrationsConfig.enabled.includes(def.name);
+    const dismissed = integrationsConfig.dismissed.includes(def.name);
+    if (enabled && def.envVar && !process.env[def.envVar]) {
+      results.push({
+        name: `integration-${def.name}-env`,
+        status: "warn",
+        message: `${def.displayName} enabled but ${def.envVar} not set.`,
+        ...def.installHint !== void 0 && { fix: def.installHint }
+      });
+    } else if (!enabled && !dismissed) {
+      results.push({
+        name: `integration-${def.name}`,
+        status: "info",
+        message: `${def.displayName} enables ${def.description.toLowerCase()}. Run \`harness integrations add ${def.name}\`.`
+      });
+    }
+  }
+  return results;
+}
+function runDoctor(cwd) {
+  const checks = [];
+  checks.push(checkNodeVersion3());
+  checks.push(...checkSlashCommands());
+  checks.push(...checkMcpConfig(cwd));
+  checks.push(...checkIntegrations(cwd));
+  const allPassed = checks.every((c) => c.status !== "fail");
+  return { checks, allPassed };
+}
+function formatCheck(check) {
+  const icons = {
+    pass: chalk4.green("\u2713"),
+    fail: chalk4.red("\u2717"),
+    warn: chalk4.yellow("!"),
+    info: chalk4.blue("\u2139")
+  };
+  const icon = icons[check.status];
+  let line = `  ${icon} ${check.message}`;
+  if ((check.status === "fail" || check.status === "warn") && 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 Command38 } from "commander";
+
+// src/commands/ci/check.ts
+import { Command as Command36 } from "commander";
+var VALID_CHECKS = [
+  "validate",
+  "deps",
+  "docs",
+  "entropy",
+  "security",
+  "perf",
+  "phase-gate",
+  "arch"
+];
+async function runCICheck(options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const input = {
+    projectRoot: process.cwd(),
+    config: configResult.value
+  };
+  if (options.skip) input.skip = options.skip;
+  if (options.failOn) input.failOn = options.failOn;
+  const result = await runCIChecks(input);
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: new CLIError(result.error.message, ExitCode.ERROR)
+    };
+  }
+  return { ok: true, value: result.value };
+}
+function parseSkip(skip) {
+  if (!skip) return [];
+  return skip.split(",").map((s) => s.trim()).filter((s) => VALID_CHECKS.includes(s));
+}
+function parseFailOn(failOn) {
+  if (failOn === "warning") return "warning";
+  return "error";
+}
+function createCheckCommand() {
+  return new Command36("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate, arch)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = resolveOutputMode(globalOpts);
+    const skip = parseSkip(opts.skip);
+    const failOn = parseFailOn(opts.failOn);
+    const result = await runCICheck({
+      configPath: globalOpts.config,
+      skip,
+      failOn
     });
     if (!result.ok) {
       if (mode === OutputMode.JSON) {
@@ -3328,9 +4062,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 fs21 from "fs";
+import * as path33 from "path";
 var ALL_CHECKS = [
   "validate",
   "deps",
@@ -3431,12 +4165,12 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs16.existsSync(".github")) return "github";
-  if (fs16.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs21.existsSync(".github")) return "github";
+  if (fs21.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function createInitCommand2() {
-  return new Command35("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
+  return new Command37("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platform = opts.platform ?? detectPlatform() ?? "generic";
     const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
@@ -3448,12 +4182,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 = path33.resolve(filename);
+    const dir = path33.dirname(targetPath);
+    fs21.mkdirSync(dir, { recursive: true });
+    fs21.writeFileSync(targetPath, content);
     if (platform === "generic" && process.platform !== "win32") {
-      fs16.chmodSync(targetPath, "755");
+      fs21.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -3466,18 +4200,359 @@ 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 Command43 } from "commander";
+
+// src/commands/hooks/init.ts
+import { Command as Command39 } from "commander";
+import * as fs22 from "fs";
+import * as path34 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" },
+  { name: "sentinel-pre", event: "PreToolUse", matcher: "*", minProfile: "strict" },
+  { name: "sentinel-post", event: "PostToolUse", 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 = path34.dirname(__filename);
+var VALID_PROFILES = ["minimal", "standard", "strict"];
+function resolveHookSourceDir() {
+  const candidate = path34.resolve(__dirname, "..", "..", "hooks");
+  if (fs22.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 = path34.join(projectDir, ".harness", "hooks");
+  fs22.mkdirSync(hooksDestDir, { recursive: true });
+  if (fs22.existsSync(hooksDestDir)) {
+    for (const entry of fs22.readdirSync(hooksDestDir)) {
+      if (entry.endsWith(".js")) {
+        fs22.unlinkSync(path34.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 = path34.join(sourceDir, `${script.name}.js`);
+    const destFile = path34.join(hooksDestDir, `${script.name}.js`);
+    if (fs22.existsSync(srcFile)) {
+      fs22.copyFileSync(srcFile, destFile);
+      copiedScripts.push(script.name);
+    }
+  }
+  const profilePath = path34.join(hooksDestDir, "profile.json");
+  fs22.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
+  const claudeDir = path34.join(projectDir, ".claude");
+  fs22.mkdirSync(claudeDir, { recursive: true });
+  const settingsPath = path34.join(claudeDir, "settings.json");
+  let existing = {};
+  if (fs22.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs22.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);
+  fs22.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: ${path34.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 fs23 from "fs";
+import * as path35 from "path";
+function listHooks(projectDir) {
+  const hooksDir = path35.join(projectDir, ".harness", "hooks");
+  const profilePath = path35.join(hooksDir, "profile.json");
+  if (!fs23.existsSync(profilePath)) {
+    return { installed: false, profile: null, hooks: [] };
+  }
+  let profile = "standard";
+  let warning;
+  try {
+    const data = JSON.parse(fs23.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: path35.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 fs24 from "fs";
+import * as path36 from "path";
+function removeHooks(projectDir) {
+  const hooksDir = path36.join(projectDir, ".harness", "hooks");
+  const settingsPath = path36.join(projectDir, ".claude", "settings.json");
+  let removed = false;
+  let settingsCleaned = false;
+  if (fs24.existsSync(hooksDir)) {
+    fs24.rmSync(hooksDir, { recursive: true, force: true });
+    removed = true;
+  }
+  if (fs24.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+      if (settings.hooks !== void 0) {
+        delete settings.hooks;
+        settingsCleaned = true;
+        if (Object.keys(settings).length === 0) {
+          fs24.unlinkSync(settingsPath);
+        } else {
+          fs24.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/add.ts
+import { Command as Command42 } from "commander";
+import * as fs25 from "fs";
+import * as path37 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path37.dirname(fileURLToPath2(import.meta.url));
+var ALIASES = {
+  sentinel: ["sentinel-pre", "sentinel-post"]
+};
+function hookSourceDir() {
+  const d = path37.resolve(__dirname2, "..", "..", "hooks");
+  if (fs25.existsSync(d)) return d;
+  throw new Error(`Hook scripts not found: ${d}`);
+}
+function readJson(p) {
+  return fs25.existsSync(p) ? JSON.parse(fs25.readFileSync(p, "utf-8")) : {};
+}
+function registerHook(s, ev, matcher, name) {
+  if (!s.hooks[ev]) s.hooks[ev] = [];
+  const cmd = `node .harness/hooks/${name}.js`;
+  if (!s.hooks[ev].some((e) => e.hooks?.some((h) => h.command === cmd))) {
+    s.hooks[ev].push({ matcher, hooks: [{ type: "command", command: cmd }] });
+  }
+}
+function addHooks(hookName, projectDir) {
+  const names = ALIASES[hookName] ?? [hookName];
+  const result = { added: [], alreadyInstalled: [], notFound: [] };
+  const srcDir = hookSourceDir();
+  const destDir = path37.join(projectDir, ".harness", "hooks");
+  fs25.mkdirSync(destDir, { recursive: true });
+  const claudeDir = path37.join(projectDir, ".claude");
+  fs25.mkdirSync(claudeDir, { recursive: true });
+  const settingsPath = path37.join(claudeDir, "settings.json");
+  const settings = readJson(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  for (const name of names) {
+    const def = HOOK_SCRIPTS.find((h) => h.name === name);
+    if (!def) {
+      result.notFound.push(name);
+      continue;
+    }
+    const src = path37.join(srcDir, `${name}.js`);
+    const dest = path37.join(destDir, `${name}.js`);
+    if (fs25.existsSync(dest)) {
+      result.alreadyInstalled.push(name);
+    } else if (!fs25.existsSync(src)) {
+      result.notFound.push(name);
+      continue;
+    } else {
+      fs25.copyFileSync(src, dest);
+      result.added.push(name);
+    }
+    registerHook(settings, def.event, def.matcher, name);
+  }
+  fs25.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return result;
+}
+function createAddCommand2() {
+  return new Command42("add").argument("<hook-name>", "Hook name or alias (e.g., sentinel)").description("Add a hook without changing the profile").action(async (hookName, _opts, cmd) => {
+    const projectDir = process.cwd();
+    try {
+      const res = addHooks(hookName, projectDir);
+      if (cmd.optsWithGlobals().json) {
+        console.log(JSON.stringify(res));
+        return;
+      }
+      if (res.notFound.length > 0) {
+        logger.error(`Unknown hook(s): ${res.notFound.join(", ")}`);
+        logger.info(`Available: ${HOOK_SCRIPTS.map((h) => h.name).join(", ")}`);
+        logger.info(`Aliases: ${Object.keys(ALIASES).join(", ")}`);
+        process.exit(2);
+      }
+      for (const n of res.added) logger.success(`Added hook: ${n}`);
+      for (const n of res.alreadyInstalled) logger.info(`Already installed: ${n}`);
+    } catch (err) {
+      logger.error(`Failed to add hook: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/hooks/index.ts
+function createHooksCommand() {
+  const command = new Command43("hooks").description("Manage Claude Code hook configurations");
+  command.addCommand(createInitCommand3());
+  command.addCommand(createListCommand3());
+  command.addCommand(createRemoveCommand());
+  command.addCommand(createAddCommand2());
+  return command;
+}
+
 // src/commands/update.ts
-import { Command as Command37 } from "commander";
+import { Command as Command44 } from "commander";
 import { execFileSync as execFileSync4 } from "child_process";
 import { realpathSync } from "fs";
 import readline2 from "readline";
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -3533,10 +4608,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve29) => {
+  return new Promise((resolve31) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve29(answer.trim().toLowerCase());
+      resolve31(answer.trim().toLowerCase());
     });
   });
 }
@@ -3552,11 +4627,11 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk5.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
 }
 function createUpdateCommand() {
-  return new Command37("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
+  return new Command44("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const pm = detectPackageManager();
     if (globalOpts.verbose) {
@@ -3578,8 +4653,8 @@ function createUpdateCommand() {
       }
       if (currentVersion) {
         console.log("");
-        logger.info(`Current CLI version: ${chalk3.dim(`v${currentVersion}`)}`);
-        logger.info(`Latest CLI version:  ${chalk3.green(`v${latestCliVersion}`)}`);
+        logger.info(`Current CLI version: ${chalk5.dim(`v${currentVersion}`)}`);
+        logger.info(`Latest CLI version:  ${chalk5.green(`v${latestCliVersion}`)}`);
         console.log("");
       }
     }
@@ -3605,7 +4680,7 @@ function createUpdateCommand() {
     } catch {
       console.log("");
       logger.error("Update failed. You can try manually:");
-      console.log(`  ${chalk3.cyan(installCmd)}`);
+      console.log(`  ${chalk5.cyan(installCmd)}`);
       process.exit(ExitCode.ERROR);
     }
     await offerRegeneration();
@@ -3614,9 +4689,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/generate.ts
-import { Command as Command38 } from "commander";
+import { Command as Command45 } 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 Command45("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platforms = opts.platforms.split(",").map((p) => p.trim());
     for (const p of platforms) {
@@ -3675,8 +4750,8 @@ function createGenerateCommand3() {
 }
 
 // src/commands/graph/scan.ts
-import { Command as Command39 } from "commander";
-import * as path29 from "path";
+import { Command as Command46 } from "commander";
+import * as path38 from "path";
 async function runScan(projectPath) {
   const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-B26DFXMP.js");
   const store = new GraphStore();
@@ -3689,13 +4764,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path29.join(projectPath, ".harness", "graph");
+  const graphDir = path38.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 Command46("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path38.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -3714,13 +4789,13 @@ function createScanCommand() {
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command40 } from "commander";
-import * as path30 from "path";
+import { Command as Command47 } from "commander";
+import * as path39 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 fs34 = await import("fs/promises");
+    const configPath = path39.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs34.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
     );
@@ -3760,7 +4835,7 @@ async function runIngest(projectPath, source, opts) {
     JiraConnector,
     SlackConnector
   } = await import("./dist-B26DFXMP.js");
-  const graphDir = path30.join(projectPath, ".harness", "graph");
+  const graphDir = path39.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -3821,13 +4896,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 Command47("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 = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -3849,12 +4924,12 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/query.ts
-import { Command as Command41 } from "commander";
-import * as path31 from "path";
+import { Command as Command48 } from "commander";
+import * as path40 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
   const { GraphStore, ContextQL } = await import("./dist-B26DFXMP.js");
   const store = new GraphStore();
-  const graphDir = path31.join(projectPath, ".harness", "graph");
+  const graphDir = path40.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -3868,9 +4943,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 Command48("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 = path40.resolve(globalOpts.config ? path40.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -3896,21 +4971,21 @@ function createQueryCommand() {
 }
 
 // src/commands/graph/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command49 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path32 from "path";
+import * as path41 from "path";
 async function runGraphStatus(projectPath) {
   const { GraphStore } = await import("./dist-B26DFXMP.js");
-  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const graphDir = path41.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 fs34 = await import("fs/promises");
+  const metaPath = path41.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs23.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs34.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -3921,8 +4996,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 = path41.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs34.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -3939,10 +5014,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path33 from "path";
+import * as path42 from "path";
 async function runGraphExport(projectPath, format) {
   const { GraphStore } = await import("./dist-B26DFXMP.js");
-  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const graphDir = path42.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
@@ -3971,13 +5046,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path34 from "path";
+import * as path43 from "path";
 function createGraphCommand() {
-  const graph = new Command42("graph").description("Knowledge graph management");
+  const graph = new Command49("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 = path43.resolve(globalOpts.config ? path43.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -4004,7 +5079,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 = path43.resolve(globalOpts.config ? path43.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);
@@ -4017,19 +5092,19 @@ function createGraphCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command43 } from "commander";
+import { Command as Command50 } from "commander";
 function createMcpCommand() {
-  return new Command43("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
-    const { startServer: startServer2 } = await import("./mcp-362EZHF4.js");
-    await startServer2();
+  return new Command50("mcp").description("Start the MCP (Model Context Protocol) server on stdio").option("--tools <tools...>", "Only register the specified tools (used by Cursor integration)").action(async (opts) => {
+    const { startServer: startServer2 } = await import("./mcp-YENEPHBW.js");
+    await startServer2(opts.tools);
   });
 }
 
 // src/commands/impact-preview.ts
-import { Command as Command44 } from "commander";
+import { Command as Command51 } from "commander";
 import { execSync as execSync3 } from "child_process";
-import * as path35 from "path";
-import * as fs17 from "fs";
+import * as path44 from "path";
+import * as fs26 from "fs";
 function getStagedFiles(cwd) {
   try {
     const output = execSync3("git diff --cached --name-only", {
@@ -4043,7 +5118,7 @@ function getStagedFiles(cwd) {
 }
 function graphExists(projectPath) {
   try {
-    return fs17.existsSync(path35.join(projectPath, ".harness", "graph", "graph.json"));
+    return fs26.existsSync(path44.join(projectPath, ".harness", "graph", "graph.json"));
   } catch {
     return false;
   }
@@ -4052,7 +5127,7 @@ function extractNodeName(id) {
   const parts = id.split(":");
   if (parts.length > 1) {
     const fullPath = parts.slice(1).join(":");
-    return path35.basename(fullPath);
+    return path44.basename(fullPath);
   }
   return id;
 }
@@ -4175,7 +5250,7 @@ function formatPerFile(perFileResults) {
   return lines.join("\n");
 }
 async function runImpactPreview(options) {
-  const projectPath = path35.resolve(options.path ?? process.cwd());
+  const projectPath = path44.resolve(options.path ?? process.cwd());
   const stagedFiles = getStagedFiles(projectPath);
   if (stagedFiles.length === 0) {
     return "Impact Preview: no staged changes";
@@ -4222,7 +5297,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 Command51("impact-preview").description("Show blast radius of staged changes using the knowledge graph").option("--detailed", "Show all affected files instead of top items").option("--per-file", "Show impact per staged file instead of aggregate").option("--path <dir>", "Project root (default: cwd)").action(async (opts) => {
     const output = await runImpactPreview({
       detailed: opts.detailed,
       perFile: opts.perFile,
@@ -4235,7 +5310,7 @@ function createImpactPreviewCommand() {
 }
 
 // src/commands/check-arch.ts
-import { Command as Command45 } from "commander";
+import { Command as Command52 } from "commander";
 import { execSync as execSync4 } from "child_process";
 function getCommitHash2(cwd) {
   try {
@@ -4330,7 +5405,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 Command52("check-arch").description("Check architecture assertions against baseline and thresholds").option("--update-baseline", "Capture current state as new baseline").option("--module <path>", "Check a single module").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -4396,20 +5471,20 @@ function createCheckArchCommand() {
 }
 
 // src/commands/blueprint.ts
-import { Command as Command46 } from "commander";
-import * as path36 from "path";
+import { Command as Command53 } from "commander";
+import * as path45 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 Command53("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 = path45.resolve(projectPath);
+      const outputDir = path45.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 ${path45.join(outputDir, "index.html")}`);
     } catch (error) {
       logger.error(
         `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
@@ -4420,16 +5495,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 Command54 } from "commander";
+import * as fs27 from "fs";
+import * as path46 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 Command54("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 = path46.resolve(projectPath);
+    const manifestPath = path46.join(rootDir, MANIFEST_FILENAME);
+    if (!fs27.existsSync(manifestPath)) {
       logger.error(
         `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -4438,7 +5513,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 = fs27.readFileSync(manifestPath, "utf-8");
       parsed = parseYaml(raw);
     } catch (err) {
       logger.error(
@@ -4452,7 +5527,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(path46.join(rootDir, "harness.config.json"));
     if (!configResult.ok) {
       logger.error(configResult.error.message);
       process.exit(1);
@@ -4470,8 +5545,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 = path46.resolve(options.output);
+    const outputPath = path46.join(outputDir, `${manifest.name}.harness-constraints.json`);
     const writeResult = await writeConfig(outputPath, bundle);
     if (!writeResult.ok) {
       logger.error(`Failed to write bundle: ${writeResult.error.message}`);
@@ -4482,25 +5557,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 fs29 from "fs";
+import * as path48 from "path";
+import { Command as Command55 } 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 fs28 from "fs";
+import * as path47 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 = fs28.mkdtempSync(path47.join(os6.tmpdir(), "harness-skill-install-"));
+  const tarballPath = path47.join(tmpDir, "package.tgz");
   try {
-    fs19.writeFileSync(tarballPath, tarballBuffer);
+    fs28.writeFileSync(tarballPath, tarballBuffer);
     execFileSync5("tar", ["-xzf", tarballPath, "-C", tmpDir], {
       timeout: 3e4
     });
-    fs19.unlinkSync(tarballPath);
+    fs28.unlinkSync(tarballPath);
   } catch (err) {
     cleanupTempDir(tmpDir);
     throw new Error(
@@ -4511,43 +5586,43 @@ function extractTarball(tarballBuffer) {
   return tmpDir;
 }
 function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
-  const files = fs19.readdirSync(extractedPkgDir);
+  const files = fs28.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 = path47.join(communityBaseDir, platform, skillName);
+    if (fs28.existsSync(targetDir)) {
+      fs28.rmSync(targetDir, { recursive: true, force: true });
     }
-    fs19.mkdirSync(targetDir, { recursive: true });
+    fs28.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 = path47.join(extractedPkgDir, file);
+      const destPath = path47.join(targetDir, file);
+      const stat = fs28.statSync(srcPath);
       if (stat.isDirectory()) {
-        fs19.cpSync(srcPath, destPath, { recursive: true });
+        fs28.cpSync(srcPath, destPath, { recursive: true });
       } else {
-        fs19.copyFileSync(srcPath, destPath);
+        fs28.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 = path47.join(communityBaseDir, platform, skillName);
+    if (fs28.existsSync(targetDir)) {
+      fs28.rmSync(targetDir, { recursive: true, force: true });
     }
   }
 }
 function cleanupTempDir(dirPath) {
   try {
-    fs19.rmSync(dirPath, { recursive: true, force: true });
+    fs28.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
 
 // src/registry/resolver.ts
-import semver2 from "semver";
+import semver3 from "semver";
 function resolveVersion(metadata, versionRange) {
   const versions = Object.keys(metadata.versions);
   if (versions.length === 0) {
@@ -4559,13 +5634,13 @@ function resolveVersion(metadata, versionRange) {
       const latestInfo = metadata.versions[latestTag];
       if (latestInfo) return latestInfo;
     }
-    const highest = semver2.maxSatisfying(versions, "*");
+    const highest = semver3.maxSatisfying(versions, "*");
     if (!highest || !metadata.versions[highest]) {
       throw new Error(`No versions available for ${metadata.name}.`);
     }
     return metadata.versions[highest];
   }
-  const matched = semver2.maxSatisfying(versions, versionRange);
+  const matched = semver3.maxSatisfying(versions, versionRange);
   if (!matched || !metadata.versions[matched]) {
     throw new Error(
       `No version of ${metadata.name} matches range ${versionRange}. Available: ${versions.join(", ")}`
@@ -4597,35 +5672,35 @@ function validateSkillYaml(parsed) {
   };
 }
 async function runLocalInstall(fromPath, options) {
-  const resolvedPath = path39.resolve(fromPath);
-  if (!fs20.existsSync(resolvedPath)) {
+  const resolvedPath = path48.resolve(fromPath);
+  if (!fs29.existsSync(resolvedPath)) {
     throw new Error(`--from path does not exist: ${resolvedPath}`);
   }
-  const stat = fs20.statSync(resolvedPath);
+  const stat = fs29.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 = fs29.readFileSync(resolvedPath);
     extractDir = extractTarball(tarballBuffer);
-    pkgDir = path39.join(extractDir, "package");
+    pkgDir = path48.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 = path48.join(pkgDir, "skill.yaml");
+    if (!fs29.existsSync(skillYamlPath)) {
       throw new Error(`No skill.yaml found at ${skillYamlPath}`);
     }
-    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs29.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 = path48.dirname(globalDir);
+    const communityBase = path48.join(skillsDir, "community");
+    const lockfilePath = path48.join(communityBase, "skills-lock.json");
     const bundledNames = getBundledSkillNames(globalDir);
     if (bundledNames.has(shortName)) {
       throw new Error(
@@ -4666,9 +5741,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 = path48.dirname(globalDir);
+  const communityBase = path48.join(skillsDir, "community");
+  const lockfilePath = path48.join(communityBase, "skills-lock.json");
   const bundledNames = getBundledSkillNames(globalDir);
   if (bundledNames.has(shortName)) {
     throw new Error(
@@ -4694,12 +5769,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 = path48.join(extractDir, "package");
+    const skillYamlPath = path48.join(extractedPkgDir, "skill.yaml");
+    if (!fs29.existsSync(skillYamlPath)) {
       throw new Error(`contains invalid skill.yaml: file not found in package`);
     }
-    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs29.readFileSync(skillYamlPath, "utf-8");
     const parsed = yamlParse(rawYaml);
     skillYaml = validateSkillYaml(parsed);
     placeSkillContent(extractedPkgDir, communityBase, shortName, skillYaml.platforms);
@@ -4738,7 +5813,7 @@ async function runInstall(skillName, options) {
   return result;
 }
 function createInstallCommand() {
-  const cmd = new Command48("install");
+  const cmd = new Command55("install");
   cmd.description("Install a community skill from the @harness-skills registry").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--version <range>", "Semver range or exact version to install").option("--force", "Force reinstall even if same version is already installed").option("--from <path>", "Install from a local directory or .tgz file").option("--registry <url>", "Use a custom npm registry URL").action(async (skill, opts) => {
     try {
       const result = await runInstall(skill, opts);
@@ -4762,15 +5837,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 fs30 from "fs/promises";
+import * as path49 from "path";
+import { Command as Command56 } 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 fs30.readFile(source, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: false, error: `Bundle file not found: ${source}` };
@@ -4793,9 +5868,9 @@ async function runInstallConstraints(options) {
   }
   const bundle = bundleResult.data;
   if (bundle.minHarnessVersion) {
-    const installed = semver3.valid(semver3.coerce(CLI_VERSION));
-    const required = semver3.valid(semver3.coerce(bundle.minHarnessVersion));
-    if (installed && required && semver3.lt(installed, required)) {
+    const installed = semver4.valid(semver4.coerce(CLI_VERSION));
+    const required = semver4.valid(semver4.coerce(bundle.minHarnessVersion));
+    if (installed && required && semver4.lt(installed, required)) {
       return {
         ok: false,
         error: `Bundle requires harness version >= ${bundle.minHarnessVersion}, but installed version is ${CLI_VERSION}. Please upgrade.`
@@ -4813,7 +5888,7 @@ async function runInstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs21.readFile(configPath, "utf-8");
+    const raw = await fs30.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -4961,7 +6036,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 path49.resolve(opts.config);
   const found = findConfigFile();
   if (!found.ok) {
     logger.error(found.error.message);
@@ -4996,9 +6071,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 = path49.dirname(configPath);
+  const lockfilePath = path49.join(projectRoot, ".harness", "constraints.lock.json");
+  const resolvedSource = path49.resolve(source);
   if (opts.forceLocal && opts.forcePackage) {
     logger.error("Cannot use both --force-local and --force-package.");
     process.exit(1);
@@ -5018,15 +6093,15 @@ async function handleInstallConstraints(source, opts) {
   logInstallResult(result.value, opts);
 }
 function createInstallConstraintsCommand() {
-  const cmd = new Command49("install-constraints");
+  const cmd = new Command56("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 fs31 from "fs/promises";
+import * as path50 from "path";
+import { Command as Command57 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -5046,7 +6121,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs22.readFile(configPath, "utf-8");
+    const raw = await fs31.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -5083,11 +6158,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command50("uninstall-constraints");
+  const cmd = new Command57("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 = path50.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -5096,8 +6171,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path41.dirname(configPath);
-    const lockfilePath = path41.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path50.dirname(configPath);
+    const lockfilePath = path50.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -5122,15 +6197,15 @@ function createUninstallConstraintsCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path42 from "path";
-import { Command as Command51 } from "commander";
+import * as path51 from "path";
+import { Command as Command58 } 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 = path51.dirname(globalDir);
+  const communityBase = path51.join(skillsDir, "community");
+  const lockfilePath = path51.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -5160,7 +6235,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command51("uninstall");
+  const cmd = new Command58("uninstall");
   cmd.description("Uninstall a community skill").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--force", "Remove even if other skills depend on this one").action(async (skill, opts) => {
     try {
       const result = await runUninstall(skill, opts);
@@ -5179,13 +6254,13 @@ function createUninstallCommand() {
 }
 
 // src/commands/orchestrator.ts
-import { Command as Command52 } from "commander";
-import * as path43 from "path";
+import { Command as Command59 } from "commander";
+import * as path52 from "path";
 import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command52("orchestrator");
+  const orchestrator = new Command59("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 = path52.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -5209,13 +6284,13 @@ function createOrchestratorCommand() {
 }
 
 // src/commands/learnings/index.ts
-import { Command as Command54 } from "commander";
+import { Command as Command61 } from "commander";
 
 // src/commands/learnings/prune.ts
-import { Command as Command53 } from "commander";
-import * as path44 from "path";
+import { Command as Command60 } from "commander";
+import * as path53 from "path";
 async function handlePrune(opts) {
-  const projectPath = path44.resolve(opts.path);
+  const projectPath = path53.resolve(opts.path);
   const result = await pruneLearnings(projectPath, opts.stream);
   if (!result.ok) {
     logger.error(result.error.message);
@@ -5254,21 +6329,666 @@ function printPatternProposals(patterns) {
   );
 }
 function createPruneCommand() {
-  return new Command53("prune").description(
+  return new Command60("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 Command61("learnings").description("Learnings management commands");
   command.addCommand(createPruneCommand());
   return command;
 }
 
+// src/commands/integrations/index.ts
+import { Command as Command66 } from "commander";
+
+// src/commands/integrations/add.ts
+import { Command as Command62 } from "commander";
+import * as fs32 from "fs";
+import * as path54 from "path";
+import chalk6 from "chalk";
+function addIntegration(cwd, name) {
+  const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
+  if (!def) {
+    return Err(
+      new CLIError(
+        `Integration '${name}' not found in registry. Run 'harness integrations list' to see available integrations.`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  if (def.tier === 0) {
+    return Err(
+      new CLIError(
+        `${def.displayName} is a Tier 0 integration, already configured by 'harness setup'. Run 'harness setup' if missing.`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  const mcpPath = path54.join(cwd, ".mcp.json");
+  const mcpEntry = {
+    command: def.mcpConfig.command
+  };
+  if (def.mcpConfig.args.length > 0) mcpEntry.args = def.mcpConfig.args;
+  if (def.mcpConfig.env) mcpEntry.env = def.mcpConfig.env;
+  writeMcpEntry(mcpPath, def.name, mcpEntry);
+  const geminiDir = path54.join(cwd, ".gemini");
+  if (fs32.existsSync(geminiDir)) {
+    const geminiPath = path54.join(geminiDir, "settings.json");
+    writeMcpEntry(geminiPath, def.name, mcpEntry);
+  }
+  const configPath = path54.join(cwd, "harness.config.json");
+  const integConfig = readIntegrationsConfig(configPath);
+  if (!integConfig.enabled.includes(def.name)) {
+    integConfig.enabled.push(def.name);
+  }
+  integConfig.dismissed = integConfig.dismissed.filter((d) => d !== def.name);
+  writeIntegrationsConfig(configPath, integConfig);
+  const envVarMissing = !!def.envVar && !process.env[def.envVar];
+  return Ok({
+    name: def.name,
+    displayName: def.displayName,
+    envVarMissing,
+    ...def.envVar !== void 0 && { envVar: def.envVar },
+    ...def.installHint !== void 0 && { installHint: def.installHint }
+  });
+}
+function createAddIntegrationCommand() {
+  return new Command62("add").description("Enable an MCP integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const result = addIntegration(cwd, name);
+    if (!result.ok) {
+      if (!globalOpts.quiet) {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+      return;
+    }
+    const { displayName, envVarMissing, envVar, installHint } = result.value;
+    if (!globalOpts.quiet) {
+      console.log("");
+      logger.success(`${displayName} integration enabled.`);
+      console.log("");
+      if (envVarMissing && envVar) {
+        logger.warn(`Set ${chalk6.bold(envVar)} in your environment to activate.`);
+        if (installHint) {
+          console.log(`  ${chalk6.dim(installHint)}`);
+        }
+        console.log("");
+      }
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/integrations/list.ts
+import { Command as Command63 } from "commander";
+import * as path55 from "path";
+import chalk7 from "chalk";
+function createListIntegrationsCommand() {
+  return new Command63("list").description("Show all MCP integrations with status").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const mcpPath = path55.join(cwd, ".mcp.json");
+    const configPath = path55.join(cwd, "harness.config.json");
+    const mcpConfig = readMcpConfig(mcpPath);
+    const integConfig = readIntegrationsConfig(configPath);
+    const mcpServers = mcpConfig.mcpServers ?? {};
+    const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
+    const tier1 = INTEGRATION_REGISTRY.filter((i) => i.tier === 1);
+    if (globalOpts.json) {
+      const entries = INTEGRATION_REGISTRY.map((i) => ({
+        name: i.name,
+        tier: i.tier,
+        configured: i.name in mcpServers,
+        enabled: integConfig.enabled.includes(i.name),
+        dismissed: integConfig.dismissed.includes(i.name),
+        envVar: i.envVar ?? null,
+        envVarSet: i.envVar ? !!process.env[i.envVar] : null
+      }));
+      console.log(JSON.stringify(entries, null, 2));
+      process.exit(ExitCode.SUCCESS);
+      return;
+    }
+    console.log("");
+    console.log("MCP Integrations:");
+    console.log("");
+    console.log("  Tier 0 (zero-config):");
+    for (const i of tier0) {
+      const configured = i.name in mcpServers;
+      const icon = configured ? chalk7.green("\u2713") : chalk7.dim("\u25CB");
+      console.log(`    ${icon} ${i.name.padEnd(22)} ${i.description}`);
+    }
+    console.log("");
+    console.log("  Tier 1 (API key required):");
+    for (const i of tier1) {
+      const configured = i.name in mcpServers;
+      const dismissed = integConfig.dismissed.includes(i.name);
+      const icon = configured ? chalk7.green("\u2713") : chalk7.dim("\u25CB");
+      let suffix = "";
+      if (dismissed) {
+        suffix = chalk7.dim("[dismissed]");
+      } else if (i.envVar) {
+        const envSet = !!process.env[i.envVar];
+        suffix = `${i.envVar} ${envSet ? chalk7.green("\u2713") : chalk7.yellow("not set")}`;
+      }
+      console.log(`    ${icon} ${i.name.padEnd(22)} ${i.description.padEnd(35)} ${suffix}`);
+    }
+    console.log("");
+    console.log(
+      `  Run '${chalk7.cyan("harness integrations add <name>")}' to enable a Tier 1 integration.`
+    );
+    console.log("");
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/integrations/remove.ts
+import { Command as Command64 } from "commander";
+import * as fs33 from "fs";
+import * as path56 from "path";
+function removeIntegration(cwd, name) {
+  const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
+  if (!def) {
+    return Err(
+      new CLIError(
+        `Integration '${name}' not found in registry. Run 'harness integrations list' to see available integrations.`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  const mcpPath = path56.join(cwd, ".mcp.json");
+  removeMcpEntry(mcpPath, def.name);
+  const geminiDir = path56.join(cwd, ".gemini");
+  if (fs33.existsSync(geminiDir)) {
+    const geminiPath = path56.join(geminiDir, "settings.json");
+    removeMcpEntry(geminiPath, def.name);
+  }
+  const configPath = path56.join(cwd, "harness.config.json");
+  const integConfig = readIntegrationsConfig(configPath);
+  integConfig.enabled = integConfig.enabled.filter((e) => e !== def.name);
+  writeIntegrationsConfig(configPath, integConfig);
+  return Ok(def.displayName);
+}
+function createRemoveIntegrationCommand() {
+  return new Command64("remove").description("Remove an MCP integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const result = removeIntegration(cwd, name);
+    if (!result.ok) {
+      if (!globalOpts.quiet) {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+      return;
+    }
+    if (!globalOpts.quiet) {
+      console.log("");
+      logger.success(`${result.value} integration removed.`);
+      console.log("");
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/integrations/dismiss.ts
+import { Command as Command65 } from "commander";
+import * as path57 from "path";
+function dismissIntegration(cwd, name) {
+  const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
+  if (!def) {
+    return Err(
+      new CLIError(
+        `Integration '${name}' not found in registry. Run 'harness integrations list' to see available integrations.`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  const configPath = path57.join(cwd, "harness.config.json");
+  const integConfig = readIntegrationsConfig(configPath);
+  if (!integConfig.dismissed.includes(def.name)) {
+    integConfig.dismissed.push(def.name);
+  }
+  integConfig.enabled = integConfig.enabled.filter((e) => e !== def.name);
+  writeIntegrationsConfig(configPath, integConfig);
+  return Ok(def.displayName);
+}
+function createDismissIntegrationCommand() {
+  return new Command65("dismiss").description("Suppress doctor recommendations for an integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const result = dismissIntegration(cwd, name);
+    if (!result.ok) {
+      if (!globalOpts.quiet) {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+      return;
+    }
+    if (!globalOpts.quiet) {
+      console.log("");
+      logger.info(
+        `${result.value} dismissed. It will no longer appear in 'harness doctor' suggestions.`
+      );
+      console.log("");
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/integrations/index.ts
+function createIntegrationsCommand() {
+  const command = new Command66("integrations").description(
+    "Manage MCP peer integrations (add, list, remove, dismiss)"
+  );
+  command.addCommand(createListIntegrationsCommand());
+  command.addCommand(createAddIntegrationCommand());
+  command.addCommand(createRemoveIntegrationCommand());
+  command.addCommand(createDismissIntegrationCommand());
+  return command;
+}
+
+// src/commands/usage.ts
+import { Command as Command67 } from "commander";
+async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-4LPXJYVZ.js");
+  const records = readCostRecords(cwd);
+  if (includeClaudeSessions) {
+    const ccRecords = parseCCRecords();
+    records.push(...ccRecords);
+  }
+  if (records.length === 0) return records;
+  const pricingData = await loadPricingData(cwd);
+  for (const record of records) {
+    if (record.model && record.costMicroUSD == null) {
+      const cost = calculateCost(record, pricingData);
+      if (cost != null) record.costMicroUSD = cost;
+    }
+  }
+  return records;
+}
+function formatMicroUSD(microUSD) {
+  if (microUSD == null) return "N/A";
+  return "$" + (microUSD / 1e6).toFixed(4);
+}
+function formatTokenCount(count) {
+  if (count >= 1e6) return (count / 1e6).toFixed(1) + "M";
+  if (count >= 1e3) return (count / 1e3).toFixed(1) + "K";
+  return String(count);
+}
+function formatModels(models) {
+  if (models.length === 0) return "unknown";
+  if (models.length === 1) return models[0] ?? "unknown";
+  return `${models[0] ?? "unknown"} and ${models.length - 1} other${models.length - 1 > 1 ? "s" : ""}`;
+}
+function registerDailyCommand(usage) {
+  usage.command("daily").description("Show per-day token usage and cost").option("--days <n>", "Number of days to show (default: 7, max: 90)", "7").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const days = Math.min(Math.max(parseInt(opts.days, 10) || 7, 1), 90);
+    const cwd = process.cwd();
+    const records = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
+    if (records.length === 0) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify([]));
+      } else {
+        logger.info("No usage data found. Run some harness sessions first.");
+      }
+      return;
+    }
+    const { aggregateByDay } = await import("./dist-4LPXJYVZ.js");
+    const dailyData = aggregateByDay(records);
+    const limited = dailyData.slice(0, days);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(limited, null, 2));
+      return;
+    }
+    const header = "Date         | Sessions | Input     | Output    | Model(s)                     | Cost";
+    const divider = "-------------|----------|-----------|-----------|------------------------------|--------";
+    logger.info(header);
+    logger.info(divider);
+    for (const day of limited) {
+      const date = day.date.padEnd(12);
+      const sessions = String(day.sessionCount).padStart(8);
+      const input = formatTokenCount(day.tokens.inputTokens).padStart(9);
+      const output = formatTokenCount(day.tokens.outputTokens).padStart(9);
+      const models = formatModels(day.models).padEnd(28);
+      const cost = formatMicroUSD(day.costMicroUSD);
+      logger.info(`${date} | ${sessions} | ${input} | ${output} | ${models} | ${cost}`);
+    }
+  });
+}
+function registerSessionsCommand(usage) {
+  usage.command("sessions").description("List recent sessions with token usage and cost").option("--limit <n>", "Number of sessions to show (default: 10, max: 100)", "10").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const limit = Math.min(Math.max(parseInt(opts.limit, 10) || 10, 1), 100);
+    const cwd = process.cwd();
+    const records = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
+    if (records.length === 0) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify([]));
+      } else {
+        logger.info("No usage data found. Run some harness sessions first.");
+      }
+      return;
+    }
+    const { aggregateBySession } = await import("./dist-4LPXJYVZ.js");
+    const sessionData = aggregateBySession(records);
+    const limited = sessionData.slice(0, limit);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(limited, null, 2));
+      return;
+    }
+    const header = "Session ID           | Started              | Duration  | Tokens    | Model                | Cost";
+    const divider = "---------------------|----------------------|-----------|-----------|----------------------|--------";
+    logger.info(header);
+    logger.info(divider);
+    for (const s of limited) {
+      const id = s.sessionId.slice(0, 20).padEnd(20);
+      const started = s.firstTimestamp.slice(0, 19).padEnd(20);
+      const durationMs = new Date(s.lastTimestamp).getTime() - new Date(s.firstTimestamp).getTime();
+      const durationMin = Math.max(1, Math.round(durationMs / 6e4));
+      const duration = `${durationMin}m`.padStart(9);
+      const tokens = formatTokenCount(s.tokens.totalTokens).padStart(9);
+      const model = (s.model ?? "unknown").slice(0, 20).padEnd(20);
+      const cost = formatMicroUSD(s.costMicroUSD);
+      logger.info(`${id} | ${started} | ${duration} | ${tokens} | ${model} | ${cost}`);
+    }
+  });
+}
+function registerSessionCommand(usage) {
+  usage.command("session <id>").description("Show detailed token breakdown for a specific session").action(async (id, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const records = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
+    const { aggregateBySession } = await import("./dist-4LPXJYVZ.js");
+    const sessionData = aggregateBySession(records);
+    const match = sessionData.find((s) => s.sessionId === id);
+    if (!match) {
+      const fuzzy = sessionData.filter(
+        (s) => s.sessionId.includes(id) || id.includes(s.sessionId.slice(0, 8))
+      );
+      const errMsg = `Session "${id}" not found.`;
+      if (fuzzy.length > 0) {
+        const suggestions = fuzzy.slice(0, 3).map((s) => s.sessionId);
+        if (globalOpts.json) {
+          console.log(JSON.stringify({ error: errMsg, suggestions }));
+        } else {
+          logger.error(errMsg);
+          logger.info("Did you mean:");
+          for (const s of suggestions) {
+            logger.info(`  ${s}`);
+          }
+        }
+      } else {
+        if (globalOpts.json) {
+          console.log(JSON.stringify({ error: errMsg, suggestions: [] }));
+        } else {
+          logger.error(errMsg);
+        }
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(match, null, 2));
+      return;
+    }
+    logger.info(`Session: ${match.sessionId}`);
+    logger.info(`Started: ${match.firstTimestamp}`);
+    logger.info(`Ended:   ${match.lastTimestamp}`);
+    logger.info(`Model:   ${match.model ?? "unknown"}`);
+    logger.info(`Source:  ${match.source}`);
+    logger.info("");
+    logger.info("Token Breakdown:");
+    logger.info(`  Input tokens:          ${formatTokenCount(match.tokens.inputTokens)}`);
+    logger.info(`  Output tokens:         ${formatTokenCount(match.tokens.outputTokens)}`);
+    logger.info(`  Total tokens:          ${formatTokenCount(match.tokens.totalTokens)}`);
+    if (match.cacheReadTokens != null) {
+      logger.info(`  Cache read tokens:     ${formatTokenCount(match.cacheReadTokens)}`);
+    }
+    if (match.cacheCreationTokens != null) {
+      logger.info(`  Cache creation tokens: ${formatTokenCount(match.cacheCreationTokens)}`);
+    }
+    logger.info("");
+    logger.info(`Cost: ${formatMicroUSD(match.costMicroUSD)}`);
+  });
+}
+function registerLatestCommand(usage) {
+  usage.command("latest").description("Show the most recently completed session cost summary").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const records = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
+    if (records.length === 0) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ error: "No usage data found" }));
+      } else {
+        logger.info("No usage data found. Run some harness sessions first.");
+      }
+      return;
+    }
+    const { aggregateBySession } = await import("./dist-4LPXJYVZ.js");
+    const sessionData = aggregateBySession(records);
+    const latest = sessionData[0];
+    if (!latest) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ error: "No session data found" }));
+      } else {
+        logger.info("No session data found.");
+      }
+      return;
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(latest, null, 2));
+      return;
+    }
+    logger.info(`Session: ${latest.sessionId}`);
+    logger.info(`Started: ${latest.firstTimestamp}`);
+    logger.info(`Ended:   ${latest.lastTimestamp}`);
+    logger.info(`Model:   ${latest.model ?? "unknown"}`);
+    logger.info(
+      `Tokens:  ${formatTokenCount(latest.tokens.totalTokens)} (${formatTokenCount(latest.tokens.inputTokens)} in / ${formatTokenCount(latest.tokens.outputTokens)} out)`
+    );
+    logger.info(`Cost:    ${formatMicroUSD(latest.costMicroUSD)}`);
+  });
+}
+function createUsageCommand() {
+  const usage = new Command67("usage").description("Token usage and cost tracking");
+  usage.option(
+    "--include-claude-sessions",
+    "Include Claude Code session data from ~/.claude/projects/"
+  );
+  registerDailyCommand(usage);
+  registerSessionsCommand(usage);
+  registerSessionCommand(usage);
+  registerLatestCommand(usage);
+  return usage;
+}
+
+// src/commands/taint.ts
+import { Command as Command68 } from "commander";
+function getProjectRoot() {
+  return process.cwd();
+}
+function registerClearCommand(taint) {
+  taint.command("clear [sessionId]").description(
+    "Clear session taint \u2014 removes taint file(s) and re-enables destructive operations"
+  ).action((sessionId) => {
+    const projectRoot = getProjectRoot();
+    const count = clearTaint(projectRoot, sessionId);
+    if (count === 0) {
+      if (sessionId) {
+        logger.info(`No taint found for session "${sessionId}".`);
+      } else {
+        logger.info("No active taint files found.");
+      }
+    } else if (sessionId) {
+      logger.info(
+        `Sentinel: taint cleared for session "${sessionId}". Destructive operations re-enabled.`
+      );
+    } else {
+      logger.info(
+        `Sentinel: cleared ${count} taint file${count === 1 ? "" : "s"}. Destructive operations re-enabled.`
+      );
+    }
+  });
+}
+function registerStatusCommand(taint) {
+  taint.command("status [sessionId]").description("Show current taint status for a session or all sessions").action((sessionId) => {
+    const projectRoot = getProjectRoot();
+    if (sessionId) {
+      const result = checkTaint(projectRoot, sessionId);
+      if (result.expired) {
+        logger.info(`Session "${sessionId}": taint expired (cleared).`);
+      } else if (result.tainted && result.state) {
+        const state = result.state;
+        const expiresAt = new Date(state.expiresAt);
+        const remaining = Math.max(0, Math.round((expiresAt.getTime() - Date.now()) / 1e3 / 60));
+        logger.info(`Session "${sessionId}": TAINTED (${state.severity})`);
+        logger.info(`  Reason: ${state.reason}`);
+        logger.info(`  Expires in: ~${remaining} minute${remaining === 1 ? "" : "s"}`);
+        logger.info(`  Findings: ${state.findings.length}`);
+      } else {
+        logger.info(`Session "${sessionId}": clean (no taint).`);
+      }
+    } else {
+      const sessions = listTaintedSessions(projectRoot);
+      if (sessions.length === 0) {
+        logger.info("No active taint sessions.");
+      } else {
+        logger.info(`Active taint sessions (${sessions.length}):`);
+        for (const id of sessions) {
+          const result = checkTaint(projectRoot, id);
+          if (result.tainted && result.state) {
+            const remaining = Math.max(
+              0,
+              Math.round((new Date(result.state.expiresAt).getTime() - Date.now()) / 1e3 / 60)
+            );
+            logger.info(`  ${id}: ${result.state.severity} \u2014 expires in ~${remaining}m`);
+          }
+        }
+      }
+    }
+  });
+}
+function createTaintCommand() {
+  const taint = new Command68("taint").description("Manage sentinel session taint state");
+  registerClearCommand(taint);
+  registerStatusCommand(taint);
+  return taint;
+}
+
+// src/commands/scan-config.ts
+import { Command as Command69 } from "commander";
+import { existsSync as existsSync30, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
+import { join as join44, relative as relative2 } from "path";
+var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
+function stripHighSeverityPatterns(content, injectionFindings) {
+  const highLines = /* @__PURE__ */ new Set();
+  for (const f of injectionFindings) {
+    if (f.severity === "high" && f.line !== void 0) {
+      highLines.add(f.line);
+    }
+  }
+  if (highLines.size === 0) return { cleaned: content, linesStripped: 0 };
+  const lines = content.split("\n");
+  let linesStripped = 0;
+  for (const lineNum of highLines) {
+    const idx = lineNum - 1;
+    if (idx >= 0 && idx < lines.length) {
+      lines[idx] = "";
+      linesStripped++;
+    }
+  }
+  return { cleaned: lines.join("\n"), linesStripped };
+}
+function applyFix(filePath, targetDir, content, injectionFindings) {
+  const hasHighSeverity = injectionFindings.some((f) => f.severity === "high");
+  if (!hasHighSeverity) return;
+  const { cleaned, linesStripped } = stripHighSeverityPatterns(content, injectionFindings);
+  if (linesStripped > 0) {
+    writeFileSync15(filePath, cleaned);
+    logger.info(
+      `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative2(targetDir, filePath).replaceAll("\\", "/")}`
+    );
+  }
+}
+function scanSingleFile(filePath, targetDir, scanner, options) {
+  if (!existsSync30(filePath)) return null;
+  let content;
+  try {
+    content = readFileSync18(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const injectionFindings = scanForInjection(content);
+  const findings = mapInjectionFindings(injectionFindings);
+  const secFindings = scanner.scanContent(content, filePath);
+  findings.push(...mapSecurityFindings(secFindings, findings));
+  if (options.fix) {
+    applyFix(filePath, targetDir, content, injectionFindings);
+  }
+  return {
+    file: relative2(targetDir, filePath).replaceAll("\\", "/"),
+    findings,
+    overallSeverity: computeOverallSeverity(findings)
+  };
+}
+async function runScanConfig(targetDir, options) {
+  const scanner = new SecurityScanner(parseSecurityConfig({}));
+  const results = [];
+  for (const configFile of CONFIG_FILES) {
+    const result = scanSingleFile(join44(targetDir, configFile), targetDir, scanner, options);
+    if (result) results.push(result);
+  }
+  return { exitCode: computeScanExitCode(results), results };
+}
+function formatTextOutput(result) {
+  if (result.results.length === 0) {
+    logger.info("scan-config: no config files found to scan.");
+    return;
+  }
+  for (const fileResult of result.results) {
+    if (fileResult.findings.length === 0) {
+      logger.info(`${fileResult.file}: clean`);
+      continue;
+    }
+    logger.info(
+      `${fileResult.file}: ${fileResult.overallSeverity} (${fileResult.findings.length} finding(s))`
+    );
+    for (const f of fileResult.findings) {
+      const lineInfo = f.line ? ` (line ${f.line})` : "";
+      logger.info(`  [${f.ruleId}] ${f.severity.toUpperCase()}: ${f.message}${lineInfo}`);
+    }
+  }
+  if (result.exitCode === 2) {
+    logger.error("scan-config: HIGH severity findings detected. Execution should be blocked.");
+  } else if (result.exitCode === 1) {
+    logger.warn("scan-config: MEDIUM severity findings detected. Session should be tainted.");
+  }
+}
+function createScanConfigCommand() {
+  const command = new Command69("scan-config").description(
+    "Scan CLAUDE.md, AGENTS.md, .gemini/settings.json, and skill.yaml for prompt injection patterns"
+  ).option("--path <dir>", "Target directory to scan", process.cwd()).option("--fix", "Strip high-severity patterns from files in-place").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : OutputMode.TEXT;
+    const result = await runScanConfig(opts.path, { fix: opts.fix });
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (mode !== OutputMode.QUIET) {
+      formatTextOutput(result);
+    }
+    process.exit(result.exitCode);
+  });
+  return command;
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command55();
+  const program = new Command70();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
@@ -5289,10 +7009,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());
@@ -5308,11 +7031,16 @@ function createProgram() {
   program.addCommand(createUninstallConstraintsCommand());
   program.addCommand(createUninstallCommand());
   program.addCommand(createOrchestratorCommand());
+  program.addCommand(createIntegrationsCommand());
+  program.addCommand(createUsageCommand());
+  program.addCommand(createTaintCommand());
+  program.addCommand(createScanConfigCommand());
   return program;
 }
 
 export {
   buildPreamble,
+  printFirstRunWelcome,
   runScan,
   runIngest,
   runQuery,