@harness-engineering/cli 1.24.1 → 1.25.0

package/dist/{chunk-ZKVLBOYA.js → chunk-AZT567I6.js}

@@ -1,22 +1,25 @@
+import {
+  generateAgentsMd
+} from "./chunk-5BQ5BOJL.js";
 import {
   generateCIWorkflow
-} from "./chunk-LOUH2LIC.js";
+} from "./chunk-EHRZMOQ2.js";
+import {
+  TemplateEngine
+} from "./chunk-FSNPBT74.js";
 import {
   generate,
   validate
 } from "./chunk-CQ553GZO.js";
 import {
   generateRuntime
-} from "./chunk-LM5Z2WCA.js";
-import {
-  generateAgentsMd
-} from "./chunk-I4QR3HNH.js";
+} from "./chunk-6VZQJ5CX.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
 import {
   executeSkill
-} from "./chunk-UQEUYRBP.js";
+} from "./chunk-WWACIIBA.js";
 import {
   ALLOWED_PERSONA_COMMANDS
 } from "./chunk-TEFCFC4H.js";
@@ -25,21 +28,21 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-W2OZK3KC.js";
+} from "./chunk-FIQL2HND.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-NV4FPO7J.js";
+} from "./chunk-AT74HEQM.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-YDRB55Q4.js";
+} from "./chunk-P7PANON5.js";
 import {
-  TemplateEngine
-} from "./chunk-FP53DDB5.js";
+  createScanCommand
+} from "./chunk-4NK7Z3BP.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -53,11 +56,11 @@ import {
   loadOrRebuildIndex,
   persistToolingConfig,
   recommend
-} from "./chunk-LY3YVKXL.js";
+} from "./chunk-RX7TUMBR.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-AVVJ5EUU.js";
+} from "./chunk-WIQA4BSH.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -71,7 +74,7 @@ import {
 } from "./chunk-6B6UN6SG.js";
 import {
   loadGraphStore
-} from "./chunk-TDLOFNNQ.js";
+} from "./chunk-BOQRTARD.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -81,11 +84,14 @@ import {
   BaselineManager,
   BlueprintGenerator,
   BundleSchema,
+  CINotifier,
   CriticalPathResolver,
   EntropyAnalyzer,
+  GitHubIssuesSyncAdapter,
   PredictionEngine,
   ProjectScanner,
   SecurityScanner,
+  SecurityTimelineManager,
   SpecImpactEstimator,
   TimelineManager,
   TypeScriptParser,
@@ -107,16 +113,20 @@ import {
   detectDeadCode,
   detectDocDrift,
   diff,
+  dist_exports,
   extractBundle,
   generateSuggestions,
   getOrCreateInstallId,
+  init_dist,
   listStreams,
   listTaintedSessions,
   loadState,
   loadStreamIndex,
+  loadTrackerSyncConfig,
   mapInjectionFindings,
   mapSecurityFindings,
   parseDiff,
+  parseFileRegions,
   parseManifest,
   parseSecurityConfig,
   pruneLearnings,
@@ -132,35 +142,41 @@ import {
   runReviewPipeline,
   scanForInjection,
   setActiveStream,
+  validateAgentConfigs,
   validateAgentsMap,
   validateDependencies,
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-PCWYYFBP.js";
+} from "./chunk-MI6MA6OP.js";
 import {
   Err,
   Ok
-} from "./chunk-5LMZA5LZ.js";
+} from "./chunk-RL4VMEXL.js";
 import {
   createCreateSkillCommand
-} from "./chunk-XNEMDKV5.js";
+} from "./chunk-RRHUCDRD.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
 import {
   SkillMetadataSchema
-} from "./chunk-ZOVATVQC.js";
+} from "./chunk-HIK6OEUF.js";
 import {
   CLIError,
   ExitCode,
   handleError
 } from "./chunk-3WGJMBKH.js";
+import {
+  __require,
+  __toCommonJS
+} from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command80 } from "commander";
+import { Command as Command83 } from "commander";
 
 // src/commands/add.ts
+init_dist();
 import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
@@ -248,7 +264,7 @@ function addDoc(name, cwd, configResult, created) {
   return Ok(void 0);
 }
 async function addSkill(name, cwd, created) {
-  const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-QCXINA5Q.js");
+  const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-6QWJHQYS.js");
   generateSkillFiles2({
     name,
     description: `${name} skill`,
@@ -346,7 +362,7 @@ function registerSkillsCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-TZQUURSP.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-WCSJHQPK.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -382,7 +398,7 @@ function registerRecentCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords } = await import("./dist-TZQUURSP.js");
+    const { readAdoptionRecords } = await import("./dist-WCSJHQPK.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -419,7 +435,7 @@ function registerSkillCommand(adoption) {
   adoption.command("skill <name>").description("Show detail for a specific skill").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-TZQUURSP.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-WCSJHQPK.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -485,6 +501,8 @@ function createAdoptionCommand() {
 import { Command as Command5 } from "commander";
 
 // src/commands/agent/run.ts
+init_dist();
+init_dist();
 import { Command as Command3 } from "commander";
 import * as path2 from "path";
 import * as childProcess from "child_process";
@@ -606,6 +624,7 @@ function createRunCommand() {
 }
 
 // src/commands/agent/review.ts
+init_dist();
 import { Command as Command4 } from "commander";
 import { execSync } from "child_process";
 async function runAgentReview(options) {
@@ -654,7 +673,9 @@ async function runAgentReview(options) {
       comment: options.comment ?? false,
       ci: options.ci ?? false,
       deep: options.deep ?? false,
-      noMechanical: options.noMechanical ?? false
+      noMechanical: options.noMechanical ?? false,
+      ...options.thorough ? { thorough: true } : {},
+      ...options.isolated ? { isolated: true } : {}
     },
     config
   });
@@ -700,7 +721,10 @@ function printReviewResult(result, mode) {
   }
 }
 function createReviewCommand() {
-  return new Command4("review").description("Run unified code review pipeline on current changes").option("--comment", "Post inline comments to GitHub PR").option("--ci", "Enable eligibility gate, non-interactive output").option("--deep", "Add threat modeling pass to security agent").option("--no-mechanical", "Skip mechanical checks").action(async (opts, cmd) => {
+  return new Command4("review").description("Run unified code review pipeline on current changes").option("--comment", "Post inline comments to GitHub PR").option("--ci", "Enable eligibility gate, non-interactive output").option("--deep", "Add threat modeling pass to security agent").option("--no-mechanical", "Skip mechanical checks").option("--thorough", "Generate task-specific rubric before reading implementation").option(
+    "--isolated",
+    "Two-stage review: spec-compliance then code-quality with disjoint context"
+  ).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = resolveReviewMode(globalOpts);
     const result = await runAgentReview({
@@ -711,7 +735,9 @@ function createReviewCommand() {
       comment: opts.comment,
       ci: opts.ci,
       deep: opts.deep,
-      noMechanical: opts.mechanical === false
+      noMechanical: opts.mechanical === false,
+      thorough: opts.thorough,
+      isolated: opts.isolated
     });
     if (!result.ok) {
       if (mode === OutputMode.JSON) console.log(JSON.stringify({ error: result.error.message }));
@@ -734,21 +760,130 @@ function createAgentCommand() {
   return command;
 }
 
-// src/commands/blueprint.ts
+// src/commands/audit-protected.ts
+init_dist();
 import { Command as Command6 } from "commander";
 import * as path3 from "path";
+import * as fs2 from "fs";
+
+// src/utils/output.ts
+function resolveOutputMode(globalOpts) {
+  if (globalOpts.json) return OutputMode.JSON;
+  if (globalOpts.quiet) return OutputMode.QUIET;
+  if (globalOpts.verbose) return OutputMode.VERBOSE;
+  return OutputMode.TEXT;
+}
+
+// src/commands/audit-protected.ts
+import { glob } from "glob";
+async function runAuditProtected(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return Err(configResult.error);
+  }
+  const config = configResult.value;
+  const rootDir = path3.resolve(cwd, config.rootDir);
+  const excludePatterns = config.entropy?.excludePatterns ?? ["**/node_modules/**", "**/*.test.ts"];
+  let files;
+  try {
+    files = await glob("**/*.{ts,tsx,js,jsx,py,sh}", {
+      cwd: rootDir,
+      ignore: excludePatterns
+    });
+  } catch (e) {
+    return Err(new CLIError(`Failed to scan files: ${e.message}`, ExitCode.ERROR));
+  }
+  const allRegions = [];
+  const allIssues = [];
+  for (const relativePath of files) {
+    const absolutePath = path3.resolve(rootDir, relativePath);
+    let content;
+    try {
+      content = fs2.readFileSync(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const { regions, issues } = parseFileRegions(relativePath, content);
+    allRegions.push(...regions);
+    allIssues.push(...issues);
+  }
+  return Ok({
+    regions: allRegions,
+    issues: allIssues,
+    fileCount: files.length
+  });
+}
+function formatRegion(region) {
+  const lineRange = region.startLine === region.endLine ? `${region.startLine}` : `${region.startLine}-${region.endLine}`;
+  const scopes = region.scopes.join(",");
+  const reason = region.reason ? ` ${region.reason}` : "";
+  return `  ${region.file}:${lineRange} [${scopes}]${reason}`;
+}
+function printAuditResult(result, formatter) {
+  const regionCount = result.regions.length;
+  const fileSet = new Set(result.regions.map((r) => r.file));
+  console.log(
+    formatter.formatSummary("Protected regions", `${regionCount} in ${fileSet.size} file(s)`, true)
+  );
+  if (regionCount > 0) {
+    console.log(`
+Found ${regionCount} protected region(s) in ${fileSet.size} file(s):
+`);
+    for (const region of result.regions) {
+      console.log(formatRegion(region));
+    }
+  }
+  if (result.issues.length > 0) {
+    console.log(`
+Issues (${result.issues.length}):`);
+    for (const issue of result.issues) {
+      console.log(`  ${issue.file}:${issue.line} \u2014 ${issue.message}`);
+    }
+  }
+}
+function createAuditProtectedCommand() {
+  const command = new Command6("audit-protected").description("Report all harness-ignore protected code regions").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = resolveOutputMode(globalOpts);
+    const formatter = new OutputFormatter(mode);
+    const result = await runAuditProtected({
+      configPath: globalOpts.config
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+    }
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify(result.value, null, 2));
+    } else if (mode !== OutputMode.QUIET || result.value.regions.length > 0) {
+      printAuditResult(result.value, formatter);
+    }
+    process.exit(result.value.issues.length > 0 ? ExitCode.VALIDATION_FAILED : ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+// src/commands/blueprint.ts
+init_dist();
+import { Command as Command7 } from "commander";
+import * as path4 from "path";
 function createBlueprintCommand() {
-  return new Command6("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 Command7("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 = path3.resolve(projectPath);
-      const outputDir = path3.resolve(options.output);
+      const rootDir = path4.resolve(projectPath);
+      const outputDir = path4.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 ${path3.join(outputDir, "index.html")}`);
+      logger.success(`Blueprint generated successfully at ${path4.join(outputDir, "index.html")}`);
     } catch (error) {
       logger.error(
         `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
@@ -759,7 +894,8 @@ function createBlueprintCommand() {
 }
 
 // src/commands/check-arch.ts
-import { Command as Command7 } from "commander";
+init_dist();
+import { Command as Command8 } from "commander";
 import { execSync as execSync2 } from "child_process";
 function getCommitHash(cwd) {
   try {
@@ -853,7 +989,7 @@ async function runCheckArch(options) {
     thresholdViolations
   });
 }
-function resolveOutputMode(globalOpts) {
+function resolveOutputMode2(globalOpts) {
   if (globalOpts.json) return OutputMode.JSON;
   if (globalOpts.quiet) return OutputMode.QUIET;
   if (globalOpts.verbose) return OutputMode.VERBOSE;
@@ -889,9 +1025,9 @@ function printArchResult(value, mode, formatter) {
   if (output) console.log(output);
 }
 function createCheckArchCommand() {
-  const command = new Command7("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 Command8("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 = resolveOutputMode(globalOpts);
+    const mode = resolveOutputMode2(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runCheckArch({
       configPath: globalOpts.config,
@@ -919,8 +1055,10 @@ function createCheckArchCommand() {
 }
 
 // src/commands/check-deps.ts
-import { Command as Command8 } from "commander";
-import * as path4 from "path";
+init_dist();
+init_dist();
+import { Command as Command9 } from "commander";
+import * as path5 from "path";
 async function runCheckDeps(options) {
   const cwd = options.cwd ?? process.cwd();
   const configResult = resolveConfig(options.configPath);
@@ -936,7 +1074,7 @@ async function runCheckDeps(options) {
   if (!config.layers || config.layers.length === 0) {
     return Ok(result);
   }
-  const rootDir = path4.resolve(cwd, config.rootDir);
+  const rootDir = path5.resolve(cwd, config.rootDir);
   const parser = new TypeScriptParser();
   const layers = config.layers.map((l) => defineLayer(l.name, [l.pattern], l.allowedDependencies));
   const layerConfig = {
@@ -1011,25 +1149,17 @@ async function runCheckDepsAction(globalOpts) {
   process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
 }
 function createCheckDepsCommand() {
-  const command = new Command8("check-deps").description("Validate dependency layers and detect circular dependencies").action(async (_opts, cmd) => {
+  const command = new Command9("check-deps").description("Validate dependency layers and detect circular dependencies").action(async (_opts, cmd) => {
     await runCheckDepsAction(cmd.optsWithGlobals());
   });
   return command;
 }
 
 // src/commands/check-docs.ts
-import { Command as Command9 } from "commander";
-import * as path5 from "path";
-
-// src/utils/output.ts
-function resolveOutputMode2(globalOpts) {
-  if (globalOpts.json) return OutputMode.JSON;
-  if (globalOpts.quiet) return OutputMode.QUIET;
-  if (globalOpts.verbose) return OutputMode.VERBOSE;
-  return OutputMode.TEXT;
-}
-
-// src/commands/check-docs.ts
+init_dist();
+init_dist();
+import { Command as Command10 } from "commander";
+import * as path6 from "path";
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
   const minCoverage = options.minCoverage ?? 80;
@@ -1038,8 +1168,8 @@ async function runCheckDocs(options) {
     return configResult;
   }
   const config = configResult.value;
-  const docsDir = path5.resolve(cwd, config.docsDir);
-  const sourceDir = path5.resolve(cwd, config.rootDir);
+  const docsDir = path6.resolve(cwd, config.docsDir);
+  const sourceDir = path6.resolve(cwd, config.rootDir);
   const coverageResult = await checkDocCoverage("project", {
     docsDir,
     sourceDir,
@@ -1106,9 +1236,9 @@ function printCheckDocsResult(value, mode, formatter) {
   }
 }
 function createCheckDocsCommand() {
-  const command = new Command9("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").action(async (opts, cmd) => {
+  const command = new Command10("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const mode = resolveOutputMode2(globalOpts);
+    const mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runCheckDocs({
       configPath: globalOpts.config,
@@ -1136,12 +1266,13 @@ function createCheckDocsCommand() {
 }
 
 // src/commands/check-perf.ts
-import { Command as Command10 } from "commander";
-import * as path6 from "path";
+init_dist();
+import { Command as Command11 } from "commander";
+import * as path7 from "path";
 async function runCheckPerf(cwd, options) {
   const runAll2 = !options.structural && !options.size && !options.coupling;
   const analyzer = new EntropyAnalyzer({
-    rootDir: path6.resolve(cwd),
+    rootDir: path7.resolve(cwd),
     analyze: {
       complexity: runAll2 || !!options.structural,
       coupling: runAll2 || !!options.coupling,
@@ -1253,15 +1384,16 @@ async function runCheckPerfAction(opts, globalOpts) {
   process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
 }
 function createCheckPerfCommand() {
-  const command = new Command10("check-perf").description("Run performance checks: structural complexity, coupling, and size budgets").option("--structural", "Run structural complexity checks only").option("--coupling", "Run coupling metric checks only").option("--size", "Run size budget checks only").action(async (opts, cmd) => {
+  const command = new Command11("check-perf").description("Run performance checks: structural complexity, coupling, and size budgets").option("--structural", "Run structural complexity checks only").option("--coupling", "Run coupling metric checks only").option("--size", "Run size budget checks only").action(async (opts, cmd) => {
     await runCheckPerfAction(opts, cmd.optsWithGlobals());
   });
   return command;
 }
 
 // src/commands/check-security.ts
-import { Command as Command11 } from "commander";
-import * as path7 from "path";
+init_dist();
+import { Command as Command12 } from "commander";
+import * as path8 from "path";
 import { execSync as execSync3 } from "child_process";
 var SEVERITY_RANK = {
   error: 3,
@@ -1274,19 +1406,19 @@ function getChangedFiles(cwd) {
       cwd,
       encoding: "utf-8"
     });
-    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path7.resolve(cwd, f));
+    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path8.resolve(cwd, f));
   } catch {
     return [];
   }
 }
 async function runCheckSecurity(cwd, options) {
-  const projectRoot = path7.resolve(cwd);
+  const projectRoot = path8.resolve(cwd);
   let configData = {};
   try {
-    const fs36 = await import("fs");
-    const configPath = path7.join(projectRoot, "harness.config.json");
-    if (fs36.existsSync(configPath)) {
-      const raw = fs36.readFileSync(configPath, "utf-8");
+    const fs41 = await import("fs");
+    const configPath = path8.join(projectRoot, "harness.config.json");
+    if (fs41.existsSync(configPath)) {
+      const raw = fs41.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -1299,7 +1431,7 @@ async function runCheckSecurity(cwd, options) {
   if (options.changedOnly) {
     filesToScan = getChangedFiles(projectRoot);
   } else {
-    const { glob } = await import("glob");
+    const { glob: glob2 } = await import("glob");
     const pattern = "**/*.{ts,tsx,js,jsx,go,py,java,rb}";
     const ignore = securityConfig.exclude ?? [
       "**/node_modules/**",
@@ -1307,9 +1439,19 @@ async function runCheckSecurity(cwd, options) {
       "**/*.test.ts",
       "**/fixtures/**"
     ];
-    filesToScan = await glob(pattern, { cwd: projectRoot, absolute: true, ignore });
+    filesToScan = await glob2(pattern, { cwd: projectRoot, absolute: true, ignore });
   }
   const result = await scanner.scanFiles(filesToScan);
+  try {
+    const commitHash = execSync3("git rev-parse HEAD", {
+      cwd: projectRoot,
+      encoding: "utf-8"
+    }).trim();
+    const timelineManager = new SecurityTimelineManager(projectRoot);
+    timelineManager.capture(result, commitHash);
+    timelineManager.updateLifecycles(result.findings, commitHash);
+  } catch {
+  }
   const threshold = options.severity ?? "warning";
   const thresholdRank = SEVERITY_RANK[threshold];
   const filtered = result.findings.filter((f) => SEVERITY_RANK[f.severity] >= thresholdRank);
@@ -1355,7 +1497,7 @@ async function runCheckSecurityAction(opts, globalOpts) {
   process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
 }
 function createCheckSecurityCommand() {
-  const command = new Command11("check-security").description("Run lightweight security scan: secrets, injection, XSS, weak crypto").option("--severity <level>", "Minimum severity threshold", "warning").hook("preAction", (thisCommand) => {
+  const command = new Command12("check-security").description("Run lightweight security scan: secrets, injection, XSS, weak crypto").option("--severity <level>", "Minimum severity threshold", "warning").hook("preAction", (thisCommand) => {
     const severity = thisCommand.opts().severity;
     if (!["error", "warning", "info"].includes(severity)) {
       logger.error(`Invalid severity: "${severity}". Must be one of: error, warning, info`);
@@ -1368,10 +1510,11 @@ function createCheckSecurityCommand() {
 }
 
 // src/commands/ci/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/commands/ci/check.ts
-import { Command as Command12 } from "commander";
+init_dist();
+import { Command as Command13 } from "commander";
 var VALID_CHECKS = [
   "validate",
   "deps",
@@ -1435,7 +1578,7 @@ function printCheckReport(report) {
   }
 }
 async function runCheckAction(opts, globalOpts) {
-  const mode = resolveOutputMode2(globalOpts);
+  const mode = resolveOutputMode(globalOpts);
   const skip = parseSkip(opts.skip);
   const failOn = parseFailOn(opts.failOn);
   const opts2 = {
@@ -1461,15 +1604,16 @@ async function runCheckAction(opts, globalOpts) {
   process.exit(report.exitCode);
 }
 function createCheckCommand() {
-  return new Command12("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate, arch)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+  return new Command13("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) => {
     await runCheckAction(opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/ci/init.ts
-import { Command as Command13 } from "commander";
-import * as fs2 from "fs";
-import * as path8 from "path";
+init_dist();
+import { Command as Command14 } from "commander";
+import * as fs3 from "fs";
+import * as path9 from "path";
 var ALL_CHECKS = [
   "validate",
   "deps",
@@ -1571,17 +1715,17 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs2.existsSync(".github")) return "github";
-  if (fs2.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs3.existsSync(".github")) return "github";
+  if (fs3.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function writeGeneratedConfig(filename, content, platform) {
-  const targetPath = path8.resolve(filename);
-  const dir = path8.dirname(targetPath);
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(targetPath, content);
+  const targetPath = path9.resolve(filename);
+  const dir = path9.dirname(targetPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(targetPath, content);
   if (platform === "generic" && process.platform !== "win32") {
-    fs2.chmodSync(targetPath, "755");
+    fs3.chmodSync(targetPath, "755");
   }
 }
 async function runInitAction(opts, globalOpts) {
@@ -1604,22 +1748,128 @@ async function runInitAction(opts, globalOpts) {
   }
 }
 function createInitCommand() {
-  return new Command13("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 Command14("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) => {
     await runInitAction(opts, cmd.optsWithGlobals());
   });
 }
 
+// src/commands/ci/notify.ts
+init_dist();
+import { Command as Command15 } from "commander";
+import * as fs4 from "fs";
+function loadReport(reportPath) {
+  try {
+    const raw = fs4.readFileSync(reportPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveToken() {
+  return process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? null;
+}
+function resolveTrackerConfig(config) {
+  const roadmap = config.roadmap;
+  const tracker = roadmap?.tracker;
+  if (!tracker || tracker.kind !== "github") return null;
+  return tracker;
+}
+async function runNotifyAction(reportPath, opts, globalOpts) {
+  const mode = resolveOutputMode(globalOpts);
+  const report = loadReport(reportPath);
+  if (!report) {
+    logger.error(`Failed to read or parse report: ${reportPath}`);
+    process.exit(ExitCode.ERROR);
+  }
+  const configResult = resolveConfig(
+    typeof globalOpts.config === "string" ? globalOpts.config : void 0
+  );
+  if (!configResult.ok) {
+    logger.error(configResult.error.message);
+    process.exit(ExitCode.ERROR);
+  }
+  const config = configResult.value;
+  const trackerConfig = resolveTrackerConfig(config);
+  if (!trackerConfig || !trackerConfig.repo) {
+    logger.error(
+      'No GitHub tracker configured. Set roadmap.tracker in harness.config.json with kind: "github" and repo: "owner/repo".'
+    );
+    process.exit(ExitCode.ERROR);
+  }
+  const token = resolveToken();
+  if (!token) {
+    logger.error("No GitHub token found. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+    process.exit(ExitCode.ERROR);
+  }
+  const adapter = new GitHubIssuesSyncAdapter({ token, config: trackerConfig });
+  const notifier = new CINotifier(adapter, trackerConfig.repo);
+  const target = opts.target;
+  if (target === "pr-comment") {
+    if (!opts.pr) {
+      logger.error("--pr <number> is required when target is pr-comment");
+      process.exit(ExitCode.ERROR);
+    }
+    const prNumber = parseInt(opts.pr, 10);
+    if (isNaN(prNumber)) {
+      logger.error(`Invalid PR number: ${opts.pr}`);
+      process.exit(ExitCode.ERROR);
+    }
+    const result = await notifier.notifyPR(report, prNumber);
+    if (!result.ok) {
+      logger.error(`Failed to post PR comment: ${result.error.message}`);
+      process.exit(ExitCode.ERROR);
+    }
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify({ target, pr: prNumber, status: "posted" }));
+    } else if (mode !== OutputMode.QUIET) {
+      logger.success(`Posted CI report as comment on PR #${prNumber}`);
+    }
+  } else if (target === "issue") {
+    if (report.exitCode === 0) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ target, status: "skipped", reason: "no failures" }));
+      } else if (mode !== OutputMode.QUIET) {
+        logger.dim("No failures \u2014 skipping issue creation");
+      }
+      return;
+    }
+    const issueOpts = {};
+    if (opts.title) issueOpts.issueTitle = opts.title;
+    if (opts.labels) issueOpts.labels = opts.labels.split(",").map((l) => l.trim());
+    const result = await notifier.notifyIssue(report, issueOpts);
+    if (!result.ok) {
+      logger.error(`Failed to create issue: ${result.error.message}`);
+      process.exit(ExitCode.ERROR);
+    }
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify({ target, ...result.value, status: "created" }));
+    } else if (mode !== OutputMode.QUIET) {
+      logger.success(`Created issue: ${result.value.url}`);
+    }
+  } else {
+    logger.error(`Unknown target: ${target}. Use "pr-comment" or "issue".`);
+    process.exit(ExitCode.ERROR);
+  }
+}
+function createNotifyCommand() {
+  return new Command15("notify").description("Post CI check results to GitHub (PR comment or issue)").argument("<report>", "Path to CI check report JSON file (from harness ci check --json)").requiredOption("--target <target>", "Notification target: pr-comment or issue").option("--pr <number>", "PR number (required for pr-comment target)").option("--title <title>", "Custom issue title (for issue target)").option("--labels <labels>", "Comma-separated labels for created issues").action(async (reportPath, opts, cmd) => {
+    await runNotifyAction(reportPath, opts, cmd.optsWithGlobals());
+  });
+}
+
 // src/commands/ci/index.ts
 function createCICommand() {
-  const command = new Command14("ci").description("CI/CD integration commands");
+  const command = new Command16("ci").description("CI/CD integration commands");
   command.addCommand(createCheckCommand());
   command.addCommand(createInitCommand());
+  command.addCommand(createNotifyCommand());
   return command;
 }
 
 // src/commands/cleanup.ts
-import { Command as Command15 } from "commander";
-import * as path9 from "path";
+init_dist();
+import { Command as Command17 } from "commander";
+import * as path10 from "path";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
@@ -1634,11 +1884,11 @@ async function runCleanup(options) {
     patternViolations: [],
     totalIssues: 0
   };
-  const rootDir = path9.resolve(cwd, config.rootDir);
-  const docsDir = path9.resolve(cwd, config.docsDir);
+  const rootDir = path10.resolve(cwd, config.rootDir);
+  const docsDir = path10.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path9.join(rootDir, "src/index.ts")],
+    ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
     docPaths: [docsDir],
     analyze: {
       drift: type === "all" || type === "drift",
@@ -1707,9 +1957,9 @@ function printCleanupResult(value, formatter) {
   }
 }
 function createCleanupCommand() {
-  const command = new Command15("cleanup").description("Detect entropy issues (doc drift, dead code, patterns)").option("-t, --type <type>", "Issue type: drift, dead-code, patterns, all", "all").action(async (opts, cmd) => {
+  const command = new Command17("cleanup").description("Detect entropy issues (doc drift, dead code, patterns)").option("-t, --type <type>", "Issue type: drift, dead-code, patterns, all", "all").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const mode = resolveOutputMode2(globalOpts);
+    const mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runCleanup({
       configPath: globalOpts.config,
@@ -1737,20 +1987,21 @@ function createCleanupCommand() {
 }
 
 // src/commands/cleanup-sessions.ts
-import { Command as Command16 } from "commander";
-import * as fs3 from "fs";
-import * as path10 from "path";
+init_dist();
+import { Command as Command18 } from "commander";
+import * as fs5 from "fs";
+import * as path11 from "path";
 var STALE_TTL_MS = 24 * 60 * 60 * 1e3;
 function getMostRecentMtime(dirPath) {
   let latest = 0;
   try {
-    const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path10.join(dirPath, entry.name);
-      const stat = fs3.statSync(fullPath);
+      const fullPath = path11.join(dirPath, entry.name);
+      const stat = fs5.statSync(fullPath);
       if (stat.mtimeMs > latest) latest = stat.mtimeMs;
     }
-    const dirStat = fs3.statSync(dirPath);
+    const dirStat = fs5.statSync(dirPath);
     if (dirStat.mtimeMs > latest) latest = dirStat.mtimeMs;
   } catch {
   }
@@ -1759,14 +2010,14 @@ function getMostRecentMtime(dirPath) {
 async function runCleanupSessions(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun ?? false;
-  const sessionsDir = path10.join(cwd, ".harness", "sessions");
+  const sessionsDir = path11.join(cwd, ".harness", "sessions");
   const result = { removed: [], kept: [] };
-  if (!fs3.existsSync(sessionsDir)) {
+  if (!fs5.existsSync(sessionsDir)) {
     return Ok(result);
   }
   let entries;
   try {
-    entries = fs3.readdirSync(sessionsDir, { withFileTypes: true });
+    entries = fs5.readdirSync(sessionsDir, { withFileTypes: true });
   } catch (err) {
     return Err(
       new CLIError(
@@ -1778,14 +2029,14 @@ async function runCleanupSessions(options) {
   const now = Date.now();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const sessionPath = path10.join(sessionsDir, entry.name);
+    const sessionPath = path11.join(sessionsDir, entry.name);
     const mostRecent = getMostRecentMtime(sessionPath);
     const ageMs = now - mostRecent;
     if (ageMs > STALE_TTL_MS) {
       result.removed.push(entry.name);
       if (!dryRun) {
         try {
-          fs3.rmSync(sessionPath, { recursive: true, force: true });
+          fs5.rmSync(sessionPath, { recursive: true, force: true });
         } catch (err) {
           return Err(
             new CLIError(
@@ -1828,9 +2079,9 @@ Cleaned up ${removed.length} stale session(s).`);
   }
 }
 function createCleanupSessionsCommand() {
-  const command = new Command16("cleanup-sessions").description("Remove stale session directories from .harness/sessions/ (no write in 24h)").option("--dry-run", "List stale sessions without deleting them", false).option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
+  const command = new Command18("cleanup-sessions").description("Remove stale session directories from .harness/sessions/ (no write in 24h)").option("--dry-run", "List stale sessions without deleting them", false).option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const cwd = path10.resolve(opts.path);
+    const cwd = path11.resolve(opts.path);
     const result = await runCleanupSessions({ cwd, dryRun: opts.dryRun });
     if (!result.ok) {
       logger.error(result.error.message);
@@ -1844,11 +2095,11 @@ function createCleanupSessionsCommand() {
 }
 
 // src/commands/dashboard.ts
-import { Command as Command17 } from "commander";
+import { Command as Command19 } from "commander";
 import { spawn } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname2, join as join7, resolve as resolve10 } from "path";
+import { dirname as dirname2, join as join6, resolve as resolve11 } from "path";
 import { setTimeout } from "timers";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
@@ -1864,20 +2115,20 @@ function resolveServerScript() {
   try {
     const pkgPath = require2.resolve("@harness-engineering/dashboard/package.json");
     const pkgDir = dirname2(pkgPath);
-    const built2 = join7(pkgDir, "dist", "server", "serve.js");
+    const built2 = join6(pkgDir, "dist", "server", "serve.js");
     if (existsSync4(built2)) return { script: built2, dev: false };
-    const dev2 = join7(pkgDir, "src", "server", "serve.ts");
+    const dev2 = join6(pkgDir, "src", "server", "serve.ts");
     if (existsSync4(dev2)) return { script: dev2, dev: true };
   } catch {
   }
   const built = [
-    join7(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
-    join7(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
+    join6(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
+    join6(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
   ].find((p) => existsSync4(p));
   if (built) return { script: built, dev: false };
   const dev = [
-    join7(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
-    join7(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
+    join6(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
+    join6(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
   ].find((p) => existsSync4(p));
   return dev ? { script: dev, dev: true } : null;
 }
@@ -1898,8 +2149,8 @@ function spawnDashboardServer(server, env) {
 function runDashboard(opts) {
   const clientPort = Number(opts.port ?? DEFAULT_CLIENT_PORT);
   const apiPort = Number(opts.apiPort ?? DEFAULT_API_PORT);
-  const projectPath = resolve10(opts.cwd ?? process.cwd());
-  const url = `http://localhost:${clientPort}`;
+  const projectPath = resolve11(opts.cwd ?? process.cwd());
+  const url = `http://localhost:${apiPort}`;
   const server = resolveServerScript();
   if (!server) {
     console.error("Could not locate the dashboard server. Run `pnpm build` in packages/dashboard.");
@@ -1919,14 +2170,14 @@ function runDashboard(opts) {
   }
 }
 function createDashboardCommand() {
-  return new Command17("dashboard").description("Start the Harness local web dashboard").option("--port <port>", "Client dev server port", String(DEFAULT_CLIENT_PORT)).option("--api-port <port>", "API server port", String(DEFAULT_API_PORT)).option("--no-open", "Do not automatically open browser").option("--cwd <path>", "Project directory (defaults to cwd)").action((opts) => runDashboard(opts));
+  return new Command19("dashboard").description("Start the Harness local web dashboard").option("--port <port>", "Client dev server port", String(DEFAULT_CLIENT_PORT)).option("--api-port <port>", "API server port", String(DEFAULT_API_PORT)).option("--no-open", "Do not automatically open browser").option("--cwd <path>", "Project directory (defaults to cwd)").action((opts) => runDashboard(opts));
 }
 
 // src/commands/doctor.ts
-import { Command as Command18 } from "commander";
-import * as fs5 from "fs";
+import { Command as Command20 } from "commander";
+import * as fs7 from "fs";
 import * as os from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 import chalk from "chalk";
 
 // src/utils/node-version.ts
@@ -2009,24 +2260,24 @@ var INTEGRATION_REGISTRY = [
 ];
 
 // src/integrations/config.ts
-import * as fs4 from "fs";
-import * as path11 from "path";
+import * as fs6 from "fs";
+import * as path12 from "path";
 function readJsonSafe(filePath) {
-  if (!fs4.existsSync(filePath)) return null;
+  if (!fs6.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeJson(filePath, data) {
-  const dir = path11.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path12.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   const tmp = filePath + ".tmp";
-  fs4.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
-  fs4.renameSync(tmp, filePath);
+  fs6.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  fs6.renameSync(tmp, filePath);
 }
 function readMcpConfig(filePath) {
   const config = readJsonSafe(filePath);
@@ -2040,7 +2291,7 @@ function writeMcpEntry(filePath, name, entry) {
   writeJson(filePath, config);
 }
 function removeMcpEntry(filePath, name) {
-  if (!fs4.existsSync(filePath)) return;
+  if (!fs6.existsSync(filePath)) return;
   const config = readMcpConfig(filePath);
   delete config.mcpServers[name];
   writeJson(filePath, config);
@@ -2079,7 +2330,7 @@ function checkNodeVersion2() {
 }
 function countCommandFiles(dir, ext) {
   try {
-    return fs5.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
+    return fs7.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
   } catch {
     return 0;
   }
@@ -2088,13 +2339,13 @@ function checkSlashCommands() {
   const platforms = [
     {
       name: "Claude Code",
-      dir: path12.join(os.homedir(), ".claude", "commands", "harness"),
+      dir: path13.join(os.homedir(), ".claude", "commands", "harness"),
       ext: ".md",
       client: "claude-code"
     },
     {
       name: "Gemini CLI",
-      dir: path12.join(os.homedir(), ".gemini", "commands", "harness"),
+      dir: path13.join(os.homedir(), ".gemini", "commands", "harness"),
       ext: ".toml",
       client: "gemini-cli"
     }
@@ -2118,7 +2369,7 @@ function checkSlashCommands() {
 }
 function checkMcpConfig(cwd) {
   const results = [];
-  const claudeConfig = readMcpConfig(path12.join(cwd, ".mcp.json"));
+  const claudeConfig = readMcpConfig(path13.join(cwd, ".mcp.json"));
   if (claudeConfig.mcpServers?.["harness"]) {
     results.push({
       name: "mcp-claude",
@@ -2133,9 +2384,9 @@ function checkMcpConfig(cwd) {
       fix: "Run: harness setup-mcp --client claude"
     });
   }
-  const geminiDir = path12.join(cwd, ".gemini");
-  if (fs5.existsSync(geminiDir)) {
-    const geminiConfig = readMcpConfig(path12.join(geminiDir, "settings.json"));
+  const geminiDir = path13.join(cwd, ".gemini");
+  if (fs7.existsSync(geminiDir)) {
+    const geminiConfig = readMcpConfig(path13.join(geminiDir, "settings.json"));
     if (geminiConfig.mcpServers?.["harness"]) {
       results.push({
         name: "mcp-gemini",
@@ -2154,12 +2405,12 @@ function checkMcpConfig(cwd) {
   return results;
 }
 function loadMcpPresence(cwd) {
-  const mcpPath = path12.join(cwd, ".mcp.json");
-  const geminiDir = path12.join(cwd, ".gemini");
-  const hasGemini = fs5.existsSync(geminiDir);
+  const mcpPath = path13.join(cwd, ".mcp.json");
+  const geminiDir = path13.join(cwd, ".gemini");
+  const hasGemini = fs7.existsSync(geminiDir);
   return {
     mcpConfig: readMcpConfig(mcpPath),
-    geminiConfig: hasGemini ? readMcpConfig(path12.join(geminiDir, "settings.json")) : null,
+    geminiConfig: hasGemini ? readMcpConfig(path13.join(geminiDir, "settings.json")) : null,
     hasGemini
   };
 }
@@ -2191,7 +2442,7 @@ function checkTier0Presence(def, presence) {
 function checkIntegrations(cwd) {
   const results = [];
   const presence = loadMcpPresence(cwd);
-  const configPath = path12.join(cwd, "harness.config.json");
+  const configPath = path13.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));
@@ -2241,7 +2492,7 @@ function formatCheck(check) {
   return line;
 }
 function createDoctorCommand() {
-  return new Command18("doctor").description("Check environment health: Node version, slash commands, MCP configuration").action((_opts, cmd) => {
+  return new Command20("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;
@@ -2266,8 +2517,9 @@ function createDoctorCommand() {
 }
 
 // src/commands/fix-drift.ts
-import { Command as Command19 } from "commander";
-import * as path13 from "path";
+init_dist();
+import { Command as Command21 } from "commander";
+import * as path14 from "path";
 async function runFixDrift(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun !== false;
@@ -2276,11 +2528,11 @@ async function runFixDrift(options) {
     return Err(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path13.resolve(cwd, config.rootDir);
-  const docsDir = path13.resolve(cwd, config.docsDir);
+  const rootDir = path14.resolve(cwd, config.rootDir);
+  const docsDir = path14.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path13.join(rootDir, "src/index.ts")],
+    ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
     docPaths: [docsDir],
     analyze: {
       drift: true,
@@ -2399,9 +2651,9 @@ function printFixDriftResult(value, mode, formatter) {
   }
 }
 function createFixDriftCommand() {
-  const command = new Command19("fix-drift").description("Auto-fix entropy issues (doc drift, dead code)").option("--no-dry-run", "Actually apply fixes (default is dry-run mode)").action(async (opts, cmd) => {
+  const command = new Command21("fix-drift").description("Auto-fix entropy issues (doc drift, dead code)").option("--no-dry-run", "Actually apply fixes (default is dry-run mode)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const mode = resolveOutputMode2(globalOpts);
+    const mode = resolveOutputMode(globalOpts);
     const formatter = new OutputFormatter(mode);
     const result = await runFixDrift({
       configPath: globalOpts.config,
@@ -2429,7 +2681,7 @@ function createFixDriftCommand() {
 }
 
 // src/commands/generate.ts
-import { Command as Command20 } from "commander";
+import { Command as Command22 } from "commander";
 function validatePlatforms(platforms) {
   for (const p of platforms) {
     if (!VALID_PLATFORMS.includes(p)) {
@@ -2489,27 +2741,27 @@ async function runGenerateAction(opts, globalOpts) {
   }
 }
 function createGenerateCommand() {
-  return new Command20("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 Command22("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) => {
     await runGenerateAction(opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/graph/index.ts
-import { Command as Command24 } from "commander";
+import { Command as Command25 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path14 from "path";
+import * as path15 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-QW5G3GX3.js");
-  const graphDir = path14.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-RADHOOXG.js");
+  const graphDir = path15.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 fs36 = await import("fs/promises");
-  const metaPath = path14.join(graphDir, "metadata.json");
+  const fs41 = await import("fs/promises");
+  const metaPath = path15.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs36.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs41.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -2520,8 +2772,8 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path14.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs36.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path15.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs41.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -2538,10 +2790,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path15 from "path";
+import * as path16 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-QW5G3GX3.js");
-  const graphDir = path15.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-RADHOOXG.js");
+  const graphDir = path16.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.");
@@ -2572,50 +2824,11 @@ async function runGraphExport(projectPath, format) {
 // src/commands/graph/index.ts
 import * as path19 from "path";
 
-// src/commands/graph/scan.ts
-import { Command as Command21 } from "commander";
-import * as path16 from "path";
-async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-QW5G3GX3.js");
-  const store = new GraphStore();
-  const start = Date.now();
-  await new CodeIngestor(store).ingest(projectPath);
-  new TopologicalLinker(store).link();
-  const knowledgeIngestor = new KnowledgeIngestor(store);
-  await knowledgeIngestor.ingestAll(projectPath);
-  try {
-    await new GitIngestor(store).ingest(projectPath);
-  } catch {
-  }
-  const graphDir = path16.join(projectPath, ".harness", "graph");
-  await store.save(graphDir);
-  return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
-}
-function createScanCommand() {
-  return new Command21("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
-    const projectPath = path16.resolve(inputPath);
-    const globalOpts = cmd.optsWithGlobals();
-    try {
-      const result = await runScan(projectPath);
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result));
-      } else {
-        console.log(
-          `Graph built: ${result.nodeCount} nodes, ${result.edgeCount} edges (${result.durationMs}ms)`
-        );
-      }
-    } catch (err) {
-      console.error("Scan failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
-    }
-  });
-}
-
 // src/commands/graph/query.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 import * as path17 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-QW5G3GX3.js");
+  const { GraphStore, ContextQL } = await import("./dist-RADHOOXG.js");
   const store = new GraphStore();
   const graphDir = path17.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -2658,19 +2871,19 @@ async function runQueryAction(rootNodeId, opts, globalOpts) {
   }
 }
 function createQueryCommand() {
-  return new Command22("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 Command23("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) => {
     await runQueryAction(rootNodeId, opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 import * as path18 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs36 = await import("fs/promises");
+    const fs41 = await import("fs/promises");
     const configPath = path18.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs36.readFile(configPath, "utf-8"));
+    const config = JSON.parse(await fs41.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
@@ -2709,7 +2922,7 @@ async function runIngest(projectPath, source, opts) {
     SlackConnector,
     CIConnector,
     ConfluenceConnector
-  } = await import("./dist-QW5G3GX3.js");
+  } = await import("./dist-RADHOOXG.js");
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
@@ -2777,7 +2990,7 @@ async function runIngest(projectPath, source, opts) {
   return result;
 }
 function createIngestCommand() {
-  return new Command23("ingest").description("Ingest data into the knowledge graph").option(
+  return new Command24("ingest").description("Ingest data into the knowledge graph").option(
     "--source <name>",
     "Source to ingest (code, knowledge, git, jira, slack, ci, confluence)"
   ).option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
@@ -2853,18 +3066,18 @@ async function runExportAction(opts, cmd) {
   }
 }
 function createGraphCommand() {
-  const graph = new Command24("graph").description("Knowledge graph management");
+  const graph = new Command25("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(runStatusAction);
   graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(runExportAction);
   return graph;
 }
 
 // src/commands/hooks/index.ts
-import { Command as Command29 } from "commander";
+import { Command as Command30 } from "commander";
 
 // src/commands/hooks/init.ts
-import { Command as Command25 } from "commander";
-import * as fs6 from "fs";
+import { Command as Command26 } from "commander";
+import * as fs8 from "fs";
 import * as path20 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -2899,7 +3112,7 @@ var __dirname2 = path20.dirname(__filename2);
 var VALID_PROFILES = ["minimal", "standard", "strict"];
 function resolveHookSourceDir() {
   const candidate = path20.resolve(__dirname2, "..", "..", "hooks");
-  if (fs6.existsSync(candidate)) {
+  if (fs8.existsSync(candidate)) {
     return candidate;
   }
   throw new Error(`Cannot locate hook scripts directory. Expected at: ${candidate}`);
@@ -2928,11 +3141,11 @@ function mergeSettings(existing, hooksConfig) {
 function initHooks(options) {
   const { profile, projectDir } = options;
   const hooksDestDir = path20.join(projectDir, ".harness", "hooks");
-  fs6.mkdirSync(hooksDestDir, { recursive: true });
-  if (fs6.existsSync(hooksDestDir)) {
-    for (const entry of fs6.readdirSync(hooksDestDir)) {
+  fs8.mkdirSync(hooksDestDir, { recursive: true });
+  if (fs8.existsSync(hooksDestDir)) {
+    for (const entry of fs8.readdirSync(hooksDestDir)) {
       if (entry.endsWith(".js")) {
-        fs6.unlinkSync(path20.join(hooksDestDir, entry));
+        fs8.unlinkSync(path20.join(hooksDestDir, entry));
       }
     }
   }
@@ -2943,20 +3156,20 @@ function initHooks(options) {
   for (const script of activeScripts) {
     const srcFile = path20.join(sourceDir, `${script.name}.js`);
     const destFile = path20.join(hooksDestDir, `${script.name}.js`);
-    if (fs6.existsSync(srcFile)) {
-      fs6.copyFileSync(srcFile, destFile);
+    if (fs8.existsSync(srcFile)) {
+      fs8.copyFileSync(srcFile, destFile);
       copiedScripts.push(script.name);
     }
   }
   const profilePath = path20.join(hooksDestDir, "profile.json");
-  fs6.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
+  fs8.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
   const claudeDir = path20.join(projectDir, ".claude");
-  fs6.mkdirSync(claudeDir, { recursive: true });
+  fs8.mkdirSync(claudeDir, { recursive: true });
   const settingsPath = path20.join(claudeDir, "settings.json");
   let existing = {};
-  if (fs6.existsSync(settingsPath)) {
+  if (fs8.existsSync(settingsPath)) {
     try {
-      existing = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+      existing = JSON.parse(fs8.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)}`,
@@ -2966,11 +3179,11 @@ function initHooks(options) {
   }
   const hooksConfig = buildSettingsHooks(profile);
   const merged = mergeSettings(existing, hooksConfig);
-  fs6.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n");
+  fs8.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n");
   return { copiedScripts, settingsPath, profilePath };
 }
 function createInitCommand2() {
-  return new Command25("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) => {
+  return new Command26("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)) {
@@ -2994,7 +3207,9 @@ function createInitCommand2() {
           `Installed ${result.copiedScripts.length} hook scripts to .harness/hooks/`
         );
         logger.info(`Profile: ${profile}`);
-        logger.info(`Settings: ${path20.relative(projectDir, result.settingsPath)}`);
+        logger.info(
+          `Settings: ${path20.relative(projectDir, result.settingsPath).replaceAll("\\", "/")}`
+        );
         logger.dim("Run 'harness hooks list' to see installed hooks");
       }
     } catch (err) {
@@ -3006,19 +3221,19 @@ function createInitCommand2() {
 }
 
 // src/commands/hooks/list.ts
-import { Command as Command26 } from "commander";
-import * as fs7 from "fs";
+import { Command as Command27 } from "commander";
+import * as fs9 from "fs";
 import * as path21 from "path";
 function listHooks(projectDir) {
   const hooksDir = path21.join(projectDir, ".harness", "hooks");
   const profilePath = path21.join(hooksDir, "profile.json");
-  if (!fs7.existsSync(profilePath)) {
+  if (!fs9.existsSync(profilePath)) {
     return { installed: false, profile: null, hooks: [] };
   }
   let profile = "standard";
   let warning;
   try {
-    const data = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -3039,7 +3254,7 @@ function listHooks(projectDir) {
   return result;
 }
 function createListCommand() {
-  return new Command26("list").description("Show installed hooks and active profile").action(async (_opts, cmd) => {
+  return new Command27("list").description("Show installed hooks and active profile").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const projectDir = process.cwd();
     const result = listHooks(projectDir);
@@ -3060,28 +3275,28 @@ function createListCommand() {
 }
 
 // src/commands/hooks/remove.ts
-import { Command as Command27 } from "commander";
-import * as fs8 from "fs";
+import { Command as Command28 } from "commander";
+import * as fs10 from "fs";
 import * as path22 from "path";
 function removeHooks(projectDir) {
   const hooksDir = path22.join(projectDir, ".harness", "hooks");
   const settingsPath = path22.join(projectDir, ".claude", "settings.json");
   let removed = false;
   let settingsCleaned = false;
-  if (fs8.existsSync(hooksDir)) {
-    fs8.rmSync(hooksDir, { recursive: true, force: true });
+  if (fs10.existsSync(hooksDir)) {
+    fs10.rmSync(hooksDir, { recursive: true, force: true });
     removed = true;
   }
-  if (fs8.existsSync(settingsPath)) {
+  if (fs10.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
       if (settings.hooks !== void 0) {
         delete settings.hooks;
         settingsCleaned = true;
         if (Object.keys(settings).length === 0) {
-          fs8.unlinkSync(settingsPath);
+          fs10.unlinkSync(settingsPath);
         } else {
-          fs8.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+          fs10.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
         }
       }
     } catch {
@@ -3090,7 +3305,7 @@ function removeHooks(projectDir) {
   return { removed, hooksDir, settingsCleaned };
 }
 function createRemoveCommand() {
-  return new Command27("remove").description("Remove harness-managed hooks from the current project").action(async (_opts, cmd) => {
+  return new Command28("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);
@@ -3112,8 +3327,8 @@ function createRemoveCommand() {
 }
 
 // src/commands/hooks/add.ts
-import { Command as Command28 } from "commander";
-import * as fs9 from "fs";
+import { Command as Command29 } from "commander";
+import * as fs11 from "fs";
 import * as path23 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = path23.dirname(fileURLToPath3(import.meta.url));
@@ -3122,11 +3337,11 @@ var ALIASES = {
 };
 function hookSourceDir() {
   const d = path23.resolve(__dirname3, "..", "..", "hooks");
-  if (fs9.existsSync(d)) return d;
+  if (fs11.existsSync(d)) return d;
   throw new Error(`Hook scripts not found: ${d}`);
 }
 function readJson(p) {
-  return fs9.existsSync(p) ? JSON.parse(fs9.readFileSync(p, "utf-8")) : {};
+  return fs11.existsSync(p) ? JSON.parse(fs11.readFileSync(p, "utf-8")) : {};
 }
 function registerHook(s, ev, matcher, name) {
   if (!s.hooks[ev]) s.hooks[ev] = [];
@@ -3140,9 +3355,9 @@ function addHooks(hookName, projectDir) {
   const result = { added: [], alreadyInstalled: [], notFound: [] };
   const srcDir = hookSourceDir();
   const destDir = path23.join(projectDir, ".harness", "hooks");
-  fs9.mkdirSync(destDir, { recursive: true });
+  fs11.mkdirSync(destDir, { recursive: true });
   const claudeDir = path23.join(projectDir, ".claude");
-  fs9.mkdirSync(claudeDir, { recursive: true });
+  fs11.mkdirSync(claudeDir, { recursive: true });
   const settingsPath = path23.join(claudeDir, "settings.json");
   const settings = readJson(settingsPath);
   if (!settings.hooks) settings.hooks = {};
@@ -3154,22 +3369,22 @@ function addHooks(hookName, projectDir) {
     }
     const src = path23.join(srcDir, `${name}.js`);
     const dest = path23.join(destDir, `${name}.js`);
-    if (fs9.existsSync(dest)) {
+    if (fs11.existsSync(dest)) {
       result.alreadyInstalled.push(name);
-    } else if (!fs9.existsSync(src)) {
+    } else if (!fs11.existsSync(src)) {
       result.notFound.push(name);
       continue;
     } else {
-      fs9.copyFileSync(src, dest);
+      fs11.copyFileSync(src, dest);
       result.added.push(name);
     }
     registerHook(settings, def.event, def.matcher, name);
   }
-  fs9.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return result;
 }
 function createAddCommand2() {
-  return new Command28("add").argument("<hook-name>", "Hook name or alias (e.g., sentinel)").description("Add a hook without changing the profile").action(async (hookName, _opts, cmd) => {
+  return new Command29("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);
@@ -3194,7 +3409,7 @@ function createAddCommand2() {
 
 // src/commands/hooks/index.ts
 function createHooksCommand() {
-  const command = new Command29("hooks").description("Manage Claude Code hook configurations");
+  const command = new Command30("hooks").description("Manage Claude Code hook configurations");
   command.addCommand(createInitCommand2());
   command.addCommand(createListCommand());
   command.addCommand(createRemoveCommand());
@@ -3203,10 +3418,10 @@ function createHooksCommand() {
 }
 
 // src/commands/impact-preview.ts
-import { Command as Command30 } from "commander";
+import { Command as Command31 } from "commander";
 import { execSync as execSync4 } from "child_process";
 import * as path24 from "path";
-import * as fs10 from "fs";
+import * as fs12 from "fs";
 function getStagedFiles(cwd) {
   try {
     const output = execSync4("git diff --cached --name-only", {
@@ -3220,7 +3435,7 @@ function getStagedFiles(cwd) {
 }
 function graphExists(projectPath) {
   try {
-    return fs10.existsSync(path24.join(projectPath, ".harness", "graph", "graph.json"));
+    return fs12.existsSync(path24.join(projectPath, ".harness", "graph", "graph.json"));
   } catch {
     return false;
   }
@@ -3402,7 +3617,7 @@ async function runImpactPreview(options) {
   return formatImpactOutput(stagedFiles, acc, options);
 }
 function createImpactPreviewCommand() {
-  const command = new Command30("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 Command31("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,
@@ -3415,28 +3630,29 @@ function createImpactPreviewCommand() {
 }
 
 // src/commands/init.ts
-import { Command as Command32 } from "commander";
+init_dist();
+import { Command as Command33 } from "commander";
 import chalk3 from "chalk";
-import * as fs13 from "fs";
+import * as fs15 from "fs";
 import * as path27 from "path";
 
 // src/commands/setup-mcp.ts
-import { Command as Command31 } from "commander";
-import * as fs12 from "fs";
+import { Command as Command32 } from "commander";
+import * as fs14 from "fs";
 import * as path26 from "path";
 import * as os2 from "os";
 import chalk2 from "chalk";
 import * as clack from "@clack/prompts";
 
 // src/integrations/toml.ts
-import * as fs11 from "fs";
+import * as fs13 from "fs";
 import * as path25 from "path";
 function writeTomlMcpEntry(filePath, name, entry) {
   const dir = path25.dirname(filePath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
   }
-  const existing = fs11.existsSync(filePath) ? fs11.readFileSync(filePath, "utf-8") : "";
+  const existing = fs13.existsSync(filePath) ? fs13.readFileSync(filePath, "utf-8") : "";
   const blockHeader = `[mcp_servers.${name}]`;
   const newBlock = serializeTomlMcpBlock(name, entry);
   let updated;
@@ -3447,8 +3663,8 @@ function writeTomlMcpEntry(filePath, name, entry) {
     updated = existing + separator + newBlock;
   }
   const tmp = filePath + ".tmp";
-  fs11.writeFileSync(tmp, updated);
-  fs11.renameSync(tmp, filePath);
+  fs13.writeFileSync(tmp, updated);
+  fs13.renameSync(tmp, filePath);
 }
 function serializeTomlMcpBlock(name, entry) {
   const lines = [`[mcp_servers.${name}]`];
@@ -3506,6 +3722,7 @@ var CURSOR_CURATED_TOOLS = [
   "get_impact",
   "detect_entropy",
   "run_security_scan",
+  "get_security_trends",
   "assess_project",
   "manage_state",
   "create_self_review",
@@ -3550,6 +3767,7 @@ var ALL_MCP_TOOLS = [
   "ingest_source",
   "generate_agent_definitions",
   "run_security_scan",
+  "get_security_trends",
   "check_performance",
   "get_perf_baselines",
   "update_perf_baselines",
@@ -3576,7 +3794,8 @@ var ALL_MCP_TOOLS = [
   "recommend_skills",
   "compute_blast_radius",
   "dispatch_skills",
-  "compact"
+  "compact",
+  "detect_constraint_emergence"
 ];
 async function runCursorToolPicker() {
   try {
@@ -3604,20 +3823,20 @@ function writeCursorMcpEntryWithTools(configPath, tools) {
   });
 }
 function readJsonFile(filePath) {
-  if (!fs12.existsSync(filePath)) return null;
+  if (!fs14.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs12.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
   } catch {
-    fs12.copyFileSync(filePath, filePath + ".bak");
+    fs14.copyFileSync(filePath, filePath + ".bak");
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
   const dir = path26.dirname(filePath);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs12.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs14.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function configureMcpServer(configPath) {
   const config = readJsonFile(configPath) ?? {};
@@ -3665,8 +3884,8 @@ function setupMcp(cwd, client) {
   if (client === "all" || client === "codex") {
     const configPath = path26.join(cwd, ".codex", "config.toml");
     const alreadyConfigured = (() => {
-      if (!fs12.existsSync(configPath)) return false;
-      const content = fs12.readFileSync(configPath, "utf-8");
+      if (!fs14.existsSync(configPath)) return false;
+      const content = fs14.readFileSync(configPath, "utf-8");
       return content.includes("[mcp_servers.harness]");
     })();
     if (alreadyConfigured) {
@@ -3739,7 +3958,7 @@ function printMcpResult(configured, skipped, trustedFolder) {
   console.log("");
 }
 function createSetupMcpCommand() {
-  return new Command31("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) => {
+  return new Command32("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();
     let configured;
@@ -3771,7 +3990,7 @@ function resolveInitDefaults(options) {
 async function runInit(options) {
   const { cwd, name, force } = resolveInitDefaults(options);
   const configPath = path27.join(cwd, "harness.config.json");
-  if (!force && fs13.existsSync(configPath)) {
+  if (!force && fs15.existsSync(configPath)) {
     return Err(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
@@ -3879,11 +4098,11 @@ async function runInitAction2(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createInitCommand3() {
-  const command = new Command32("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("--language <language>", "Target language (typescript, python, go, rust, java)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
+  const command = new Command33("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("-t, --template <template>", "Specific template name (e.g. orchestrator)").option("--framework <framework>", "Framework overlay (nextjs)").option("--language <language>", "Target language (typescript, python, go, rust, java)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     await runInitAction2({
       name: opts.name,
-      level: opts.level,
+      level: opts.template ?? opts.level,
       framework: opts.framework,
       language: opts.language,
       force: opts.force,
@@ -3894,15 +4113,15 @@ function createInitCommand3() {
 }
 
 // src/commands/install.ts
-import * as fs18 from "fs";
+import * as fs20 from "fs";
 import * as os5 from "os";
 import * as path32 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
-import { Command as Command33 } from "commander";
+import { Command as Command34 } from "commander";
 import { parse as yamlParse } from "yaml";
 
 // src/registry/npm-client.ts
-import * as fs14 from "fs";
+import * as fs16 from "fs";
 import * as path28 from "path";
 import * as os3 from "os";
 var NPM_REGISTRY = "https://registry.npmjs.org";
@@ -3929,7 +4148,7 @@ function readNpmrcToken(registryUrl) {
   const candidates = [path28.join(process.cwd(), ".npmrc"), path28.join(os3.homedir(), ".npmrc")];
   for (const npmrcPath of candidates) {
     try {
-      const content = fs14.readFileSync(npmrcPath, "utf-8");
+      const content = fs16.readFileSync(npmrcPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (trimmed.startsWith(registryPath)) {
@@ -4024,19 +4243,19 @@ async function searchNpmRegistry(query, registryUrl) {
 }
 
 // src/registry/tarball.ts
-import * as fs15 from "fs";
+import * as fs17 from "fs";
 import * as path29 from "path";
 import * as os4 from "os";
 import { execFileSync as execFileSync2 } from "child_process";
 function extractTarball(tarballBuffer) {
-  const tmpDir = fs15.mkdtempSync(path29.join(os4.tmpdir(), "harness-skill-install-"));
+  const tmpDir = fs17.mkdtempSync(path29.join(os4.tmpdir(), "harness-skill-install-"));
   const tarballPath = path29.join(tmpDir, "package.tgz");
   try {
-    fs15.writeFileSync(tarballPath, tarballBuffer);
+    fs17.writeFileSync(tarballPath, tarballBuffer);
     execFileSync2("tar", ["-xzf", tarballPath, "-C", tmpDir], {
       timeout: 3e4
     });
-    fs15.unlinkSync(tarballPath);
+    fs17.unlinkSync(tarballPath);
   } catch (err) {
     cleanupTempDir(tmpDir);
     throw new Error(
@@ -4047,22 +4266,22 @@ function extractTarball(tarballBuffer) {
   return tmpDir;
 }
 function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
-  const files = fs15.readdirSync(extractedPkgDir);
+  const files = fs17.readdirSync(extractedPkgDir);
   for (const platform of platforms) {
     const targetDir = path29.join(communityBaseDir, platform, skillName);
-    if (fs15.existsSync(targetDir)) {
-      fs15.rmSync(targetDir, { recursive: true, force: true });
+    if (fs17.existsSync(targetDir)) {
+      fs17.rmSync(targetDir, { recursive: true, force: true });
     }
-    fs15.mkdirSync(targetDir, { recursive: true });
+    fs17.mkdirSync(targetDir, { recursive: true });
     for (const file of files) {
       if (file === "package.json" || file === "node_modules") continue;
       const srcPath = path29.join(extractedPkgDir, file);
       const destPath = path29.join(targetDir, file);
-      const stat = fs15.statSync(srcPath);
+      const stat = fs17.statSync(srcPath);
       if (stat.isDirectory()) {
-        fs15.cpSync(srcPath, destPath, { recursive: true });
+        fs17.cpSync(srcPath, destPath, { recursive: true });
       } else {
-        fs15.copyFileSync(srcPath, destPath);
+        fs17.copyFileSync(srcPath, destPath);
       }
     }
   }
@@ -4070,14 +4289,14 @@ function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platfor
 function removeSkillContent(communityBaseDir, skillName, platforms) {
   for (const platform of platforms) {
     const targetDir = path29.join(communityBaseDir, platform, skillName);
-    if (fs15.existsSync(targetDir)) {
-      fs15.rmSync(targetDir, { recursive: true, force: true });
+    if (fs17.existsSync(targetDir)) {
+      fs17.rmSync(targetDir, { recursive: true, force: true });
     }
   }
 }
 function cleanupTempDir(dirPath) {
   try {
-    fs15.rmSync(dirPath, { recursive: true, force: true });
+    fs17.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
@@ -4119,7 +4338,7 @@ function findDependentsOf(lockfile, targetPackageName) {
 }
 
 // src/registry/lockfile.ts
-import * as fs16 from "fs";
+import * as fs18 from "fs";
 import * as path30 from "path";
 function createEmptyLockfile() {
   return { version: 1, skills: {} };
@@ -4140,10 +4359,10 @@ function sortedStringify(obj) {
   );
 }
 function readLockfile2(filePath) {
-  if (!fs16.existsSync(filePath)) {
+  if (!fs18.existsSync(filePath)) {
     return createEmptyLockfile();
   }
-  const raw = fs16.readFileSync(filePath, "utf-8");
+  const raw = fs18.readFileSync(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -4161,8 +4380,8 @@ function readLockfile2(filePath) {
 }
 function writeLockfile2(filePath, lockfile) {
   const dir = path30.dirname(filePath);
-  fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
+  fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
 }
 function updateLockfileEntry(lockfile, name, entry) {
   return {
@@ -4185,17 +4404,17 @@ function removeLockfileEntry(lockfile, name) {
 }
 
 // src/registry/bundled-skills.ts
-import * as fs17 from "fs";
+import * as fs19 from "fs";
 import * as path31 from "path";
 function getBundledSkillNames(bundledSkillsDir) {
-  if (!fs17.existsSync(bundledSkillsDir)) {
+  if (!fs19.existsSync(bundledSkillsDir)) {
     return /* @__PURE__ */ new Set();
   }
-  const entries = fs17.readdirSync(bundledSkillsDir);
+  const entries = fs19.readdirSync(bundledSkillsDir);
   const names = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     try {
-      const stat = fs17.statSync(path31.join(bundledSkillsDir, String(entry)));
+      const stat = fs19.statSync(path31.join(bundledSkillsDir, String(entry)));
       if (stat.isDirectory()) {
         names.add(String(entry));
       }
@@ -4243,7 +4462,7 @@ function parseGitHubRef(from) {
   return null;
 }
 function cloneGitHubRepo(owner, repo, ref) {
-  const tmpDir = fs18.mkdtempSync(path32.join(os5.tmpdir(), "harness-gh-install-"));
+  const tmpDir = fs20.mkdtempSync(path32.join(os5.tmpdir(), "harness-gh-install-"));
   const url = `https://github.com/${owner}/${repo}.git`;
   try {
     const cloneArgs = ["clone", "--depth", "1"];
@@ -4264,12 +4483,12 @@ function discoverSkillDirs(rootDir) {
   const skillDirs = [];
   function scan(dir, depth) {
     if (depth > 3) return;
-    if (!fs18.existsSync(dir)) return;
-    if (fs18.existsSync(path32.join(dir, "skill.yaml"))) {
+    if (!fs20.existsSync(dir)) return;
+    if (fs20.existsSync(path32.join(dir, "skill.yaml"))) {
       skillDirs.push(dir);
       return;
     }
-    const entries = fs18.readdirSync(dir, { withFileTypes: true });
+    const entries = fs20.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
@@ -4281,15 +4500,15 @@ function discoverSkillDirs(rootDir) {
 }
 function resolveLocalPkgDir(fromPath) {
   const resolvedPath = path32.resolve(fromPath);
-  if (!fs18.existsSync(resolvedPath)) {
+  if (!fs20.existsSync(resolvedPath)) {
     throw new Error(`--from path does not exist: ${resolvedPath}`);
   }
-  const stat = fs18.statSync(resolvedPath);
+  const stat = fs20.statSync(resolvedPath);
   if (stat.isDirectory()) {
     return { pkgDir: resolvedPath, extractDir: null };
   }
   if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
-    const tarballBuffer = fs18.readFileSync(resolvedPath);
+    const tarballBuffer = fs20.readFileSync(resolvedPath);
     const extractDir = extractTarball(tarballBuffer);
     return { pkgDir: path32.join(extractDir, "package"), extractDir };
   }
@@ -4297,10 +4516,10 @@ function resolveLocalPkgDir(fromPath) {
 }
 function installSkillDir(pkgDir, resolvedPath, options) {
   const skillYamlPath = path32.join(pkgDir, "skill.yaml");
-  if (!fs18.existsSync(skillYamlPath)) {
+  if (!fs20.existsSync(skillYamlPath)) {
     throw new Error(`No skill.yaml found at ${skillYamlPath}`);
   }
-  const skillYaml = validateSkillYaml(yamlParse(fs18.readFileSync(skillYamlPath, "utf-8")));
+  const skillYaml = validateSkillYaml(yamlParse(fs20.readFileSync(skillYamlPath, "utf-8")));
   const shortName = skillYaml.name;
   const { communityBase, lockfilePath } = resolveCommunityBase(options.global ?? false);
   if (!options.global) {
@@ -4372,7 +4591,7 @@ async function runInstall(skillName, options) {
       };
     }
     const resolvedFrom = path32.resolve(options.from);
-    if (fs18.existsSync(resolvedFrom) && fs18.statSync(resolvedFrom).isDirectory() && !fs18.existsSync(path32.join(resolvedFrom, "skill.yaml"))) {
+    if (fs20.existsSync(resolvedFrom) && fs20.statSync(resolvedFrom).isDirectory() && !fs20.existsSync(path32.join(resolvedFrom, "skill.yaml"))) {
       const results = await runBulkInstall(resolvedFrom, options);
       const installed = results.filter((r) => r.installed);
       return {
@@ -4415,10 +4634,10 @@ async function runInstall(skillName, options) {
   try {
     const extractedPkgDir = path32.join(extractDir, "package");
     const skillYamlPath = path32.join(extractedPkgDir, "skill.yaml");
-    if (!fs18.existsSync(skillYamlPath)) {
+    if (!fs20.existsSync(skillYamlPath)) {
       throw new Error(`contains invalid skill.yaml: file not found in package`);
     }
-    const rawYaml = fs18.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
     const parsed = yamlParse(rawYaml);
     skillYaml = validateSkillYaml(parsed);
     placeSkillContent(extractedPkgDir, communityBase, shortName, skillYaml.platforms);
@@ -4458,7 +4677,7 @@ async function runInstall(skillName, options) {
   return result;
 }
 function createInstallCommand() {
-  const cmd = new Command33("install");
+  const cmd = new Command34("install");
   cmd.description("Install skills from npm registry, local directory, or GitHub repository").argument("<skill>", 'Skill name, @harness-skills/scoped package, or "." for bulk install').option("--version <range>", "Semver range or exact version to install").option("--force", "Force reinstall even if same version is already installed").option(
     "--from <source>",
     "Install from local path, directory, or GitHub (github:owner/repo, https://github.com/owner/repo)"
@@ -4491,15 +4710,16 @@ function createInstallCommand() {
 }
 
 // src/commands/install-constraints.ts
-import * as fs19 from "fs/promises";
+init_dist();
+import * as fs21 from "fs/promises";
 import * as path33 from "path";
-import { Command as Command34 } from "commander";
+import { Command as Command35 } from "commander";
 import semver3 from "semver";
 async function runInstallConstraints(options) {
   const { source, configPath, lockfilePath } = options;
   let rawBundle;
   try {
-    rawBundle = await fs19.readFile(source, "utf-8");
+    rawBundle = await fs21.readFile(source, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: false, error: `Bundle file not found: ${source}` };
@@ -4542,7 +4762,7 @@ async function runInstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs19.readFile(configPath, "utf-8");
+    const raw = await fs21.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -4747,17 +4967,18 @@ async function handleInstallConstraints(source, opts) {
   logInstallResult(result.value, opts);
 }
 function createInstallConstraintsCommand() {
-  const cmd = new Command34("install-constraints");
+  const cmd = new Command35("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/integrations/index.ts
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 
 // src/commands/integrations/add.ts
-import { Command as Command35 } from "commander";
-import * as fs20 from "fs";
+init_dist();
+import { Command as Command36 } from "commander";
+import * as fs22 from "fs";
 import * as path34 from "path";
 import chalk4 from "chalk";
 function buildMcpEntry(def) {
@@ -4769,7 +4990,7 @@ function buildMcpEntry(def) {
 function writeMcpEntries(cwd, defName, mcpEntry) {
   writeMcpEntry(path34.join(cwd, ".mcp.json"), defName, mcpEntry);
   const geminiDir = path34.join(cwd, ".gemini");
-  if (fs20.existsSync(geminiDir)) {
+  if (fs22.existsSync(geminiDir)) {
     writeMcpEntry(path34.join(geminiDir, "settings.json"), defName, mcpEntry);
   }
 }
@@ -4820,7 +5041,7 @@ function printAddSuccess(value) {
   }
 }
 function createAddIntegrationCommand() {
-  return new Command35("add").description("Enable an MCP integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+  return new Command36("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 result = addIntegration(process.cwd(), name);
     if (!result.ok) {
@@ -4834,7 +5055,7 @@ function createAddIntegrationCommand() {
 }
 
 // src/commands/integrations/list.ts
-import { Command as Command36 } from "commander";
+import { Command as Command37 } from "commander";
 import * as path35 from "path";
 import chalk5 from "chalk";
 function printTier0Integrations(tier0, mcpServers) {
@@ -4891,12 +5112,13 @@ async function runListIntegrations(globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createListIntegrationsCommand() {
-  return new Command36("list").description("Show all MCP integrations with status").action(async (_opts, cmd) => runListIntegrations(cmd.optsWithGlobals()));
+  return new Command37("list").description("Show all MCP integrations with status").action(async (_opts, cmd) => runListIntegrations(cmd.optsWithGlobals()));
 }
 
 // src/commands/integrations/remove.ts
-import { Command as Command37 } from "commander";
-import * as fs21 from "fs";
+init_dist();
+import { Command as Command38 } from "commander";
+import * as fs23 from "fs";
 import * as path36 from "path";
 function removeIntegration(cwd, name) {
   const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
@@ -4911,7 +5133,7 @@ function removeIntegration(cwd, name) {
   const mcpPath = path36.join(cwd, ".mcp.json");
   removeMcpEntry(mcpPath, def.name);
   const geminiDir = path36.join(cwd, ".gemini");
-  if (fs21.existsSync(geminiDir)) {
+  if (fs23.existsSync(geminiDir)) {
     const geminiPath = path36.join(geminiDir, "settings.json");
     removeMcpEntry(geminiPath, def.name);
   }
@@ -4922,7 +5144,7 @@ function removeIntegration(cwd, name) {
   return Ok(def.displayName);
 }
 function createRemoveIntegrationCommand() {
-  return new Command37("remove").description("Remove an MCP integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+  return new Command38("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);
@@ -4943,7 +5165,8 @@ function createRemoveIntegrationCommand() {
 }
 
 // src/commands/integrations/dismiss.ts
-import { Command as Command38 } from "commander";
+init_dist();
+import { Command as Command39 } from "commander";
 import * as path37 from "path";
 function dismissIntegration(cwd, name) {
   const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
@@ -4965,7 +5188,7 @@ function dismissIntegration(cwd, name) {
   return Ok(def.displayName);
 }
 function createDismissIntegrationCommand() {
-  return new Command38("dismiss").description("Suppress doctor recommendations for an integration").argument("<name>", "Integration name (e.g. perplexity, augment-code)").action(async (name, _opts, cmd) => {
+  return new Command39("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);
@@ -4989,7 +5212,7 @@ function createDismissIntegrationCommand() {
 
 // src/commands/integrations/index.ts
 function createIntegrationsCommand() {
-  const command = new Command39("integrations").description(
+  const command = new Command40("integrations").description(
     "Manage MCP peer integrations (add, list, remove, dismiss)"
   );
   command.addCommand(createListIntegrationsCommand());
@@ -5000,10 +5223,11 @@ function createIntegrationsCommand() {
 }
 
 // src/commands/learnings/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command42 } from "commander";
 
 // src/commands/learnings/prune.ts
-import { Command as Command40 } from "commander";
+init_dist();
+import { Command as Command41 } from "commander";
 import * as path38 from "path";
 async function handlePrune(opts) {
   const projectPath = path38.resolve(opts.path);
@@ -5045,23 +5269,23 @@ function printPatternProposals(patterns) {
   );
 }
 function createPruneCommand() {
-  return new Command40("prune").description(
+  return new Command41("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 Command41("learnings").description("Learnings management commands");
+  const command = new Command42("learnings").description("Learnings management commands");
   command.addCommand(createPruneCommand());
   return command;
 }
 
 // src/commands/linter/index.ts
-import { Command as Command44 } from "commander";
+import { Command as Command45 } from "commander";
 
 // src/commands/linter/generate.ts
-import { Command as Command42 } from "commander";
+import { Command as Command43 } from "commander";
 function formatGenerateError(e) {
   switch (e.type) {
     case "parse":
@@ -5105,7 +5329,7 @@ function handleSuccess(result, useJson) {
 Generated ${result.rulesGenerated.length} rules to ${result.outputDir}`);
 }
 function createGenerateCommand2() {
-  return new Command42("generate").description("Generate ESLint rules from harness-linter.yml").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("-o, --output <dir>", "Override output directory").option("--clean", "Remove existing files before generating").option("--dry-run", "Preview without writing files").option("--json", "Output as JSON").option("--verbose", "Show detailed output").action(async (options) => {
+  return new Command43("generate").description("Generate ESLint rules from harness-linter.yml").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("-o, --output <dir>", "Override output directory").option("--clean", "Remove existing files before generating").option("--dry-run", "Preview without writing files").option("--json", "Output as JSON").option("--verbose", "Show detailed output").action(async (options) => {
     try {
       if (options.verbose) logger.info(`Parsing config: ${options.config}`);
       const result = await generate({
@@ -5127,9 +5351,9 @@ function createGenerateCommand2() {
 }
 
 // src/commands/linter/validate.ts
-import { Command as Command43 } from "commander";
+import { Command as Command44 } from "commander";
 function createValidateCommand() {
-  return new Command43("validate").description("Validate harness-linter.yml config").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("--json", "Output as JSON").action(async (options) => {
+  return new Command44("validate").description("Validate harness-linter.yml config").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("--json", "Output as JSON").action(async (options) => {
     try {
       const result = await validate({ configPath: options.config });
       if (options.json) {
@@ -5148,7 +5372,7 @@ function createValidateCommand() {
 
 // src/commands/linter/index.ts
 function createLinterCommand() {
-  const linter = new Command44("linter").description(
+  const linter = new Command45("linter").description(
     "Generate and validate ESLint rules from YAML config"
   );
   linter.addCommand(createGenerateCommand2());
@@ -5157,21 +5381,60 @@ function createLinterCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command45 } from "commander";
+import { Command as Command46 } from "commander";
+var VALID_TIERS = /* @__PURE__ */ new Set(["core", "standard", "full"]);
+function parseTier(value) {
+  const lower = value.toLowerCase();
+  if (!VALID_TIERS.has(lower)) {
+    throw new Error(`Invalid tier "${value}". Expected one of: core, standard, full.`);
+  }
+  return lower;
+}
+function parseBudget(value) {
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`Invalid --budget-tokens "${value}". Expected a non-negative integer.`);
+  }
+  return n;
+}
 function createMcpCommand() {
-  return new Command45("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-JZG22CYT.js");
-    await startServer2(opts.tools);
+  return new Command46("mcp").description("Start the MCP (Model Context Protocol) server on stdio").option("--tools <tools...>", "Only register the specified tools (used by Cursor integration)").option(
+    "--tier <core|standard|full>",
+    "Load a preset tool tier instead of all tools",
+    parseTier
+  ).option(
+    "--budget-tokens <n>",
+    "Auto-select tier to fit this baseline token budget",
+    parseBudget
+  ).action(async (opts) => {
+    const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
+      import("./mcp-2553PNUC.js"),
+      import("./tool-tiers-7QGZ3FKY.js")
+    ]);
+    if (opts.tools && opts.tools.length > 0) {
+      await startServer2(opts.tools);
+      return;
+    }
+    if (opts.tier || opts.budgetTokens !== void 0) {
+      const definitions = getToolDefinitions2();
+      const selection = selectTier(definitions, {
+        ...opts.tier ? { overrideTier: opts.tier } : {},
+        ...opts.budgetTokens !== void 0 ? { tokenBudget: opts.budgetTokens } : {}
+      });
+      await startServer2(selection.filter);
+      return;
+    }
+    await startServer2();
   });
 }
 
 // src/commands/orchestrator.ts
-import { Command as Command46 } from "commander";
+import { Command as Command47 } from "commander";
 import * as path39 from "path";
 import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command46("orchestrator");
-  orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to WORKFLOW.md", "WORKFLOW.md").action(async (opts) => {
+  const orchestrator = new Command47("orchestrator");
+  orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to WORKFLOW.md", "WORKFLOW.md").option("--headless", "Run without TUI (server-only mode for use with web dashboard)").action(async (opts) => {
     const workflowPath = path39.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader();
     const result = await loader.loadWorkflow(workflowPath);
@@ -5188,23 +5451,32 @@ function createOrchestratorCommand() {
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
     daemon.start();
-    const { waitUntilExit } = launchTUI(daemon);
-    await waitUntilExit();
+    if (opts.headless) {
+      logger.info(
+        "Orchestrator running in headless mode (no TUI). Use the web dashboard or Ctrl+C to stop."
+      );
+      await new Promise(() => {
+      });
+    } else {
+      const { waitUntilExit } = launchTUI(daemon);
+      await waitUntilExit();
+    }
     process.exit(ExitCode.SUCCESS);
   });
   return orchestrator;
 }
 
 // src/commands/perf.ts
-import { Command as Command47 } from "commander";
+init_dist();
+import { Command as Command48 } from "commander";
 import * as path40 from "path";
 function registerBenchCommand(perf) {
-  perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob, _opts, cmd) => {
+  perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-TZQUURSP.js");
+    const { BenchmarkRunner } = await import("./dist-WCSJHQPK.js");
     const runner = new BenchmarkRunner();
-    const benchFiles = runner.discover(cwd, glob);
+    const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
       if (globalOpts.json) {
         console.log(JSON.stringify({ benchFiles: [], message: "No .bench.ts files found" }));
@@ -5214,7 +5486,7 @@ function registerBenchCommand(perf) {
       return;
     }
     logBenchDiscovery(globalOpts.json, benchFiles);
-    const result = await runner.run(glob ? { cwd, glob } : { cwd });
+    const result = await runner.run(glob2 ? { cwd, glob: glob2 } : { cwd });
     outputBenchResults(globalOpts.json, result);
   });
 }
@@ -5266,7 +5538,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-TZQUURSP.js");
+  const { BenchmarkRunner } = await import("./dist-WCSJHQPK.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -5307,7 +5579,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-TZQUURSP.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-WCSJHQPK.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path40.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -5368,7 +5640,7 @@ function registerCriticalPathsCommand(perf) {
   });
 }
 function createPerfCommand() {
-  const perf = new Command47("perf").description("Performance benchmark and baseline management");
+  const perf = new Command48("perf").description("Performance benchmark and baseline management");
   registerBenchCommand(perf);
   registerBaselinesCommands(perf);
   registerReportCommand(perf);
@@ -5377,10 +5649,10 @@ function createPerfCommand() {
 }
 
 // src/commands/persona/index.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/commands/persona/list.ts
-import { Command as Command48 } from "commander";
+import { Command as Command49 } from "commander";
 function printPersonaList(personas) {
   if (personas.length === 0) {
     logger.info("No personas found.");
@@ -5394,7 +5666,7 @@ function printPersonaList(personas) {
   }
 }
 function createListCommand2() {
-  return new Command48("list").description("List available agent personas").action(async (_opts, cmd) => {
+  return new Command49("list").description("List available agent personas").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
     const result = listPersonas(personasDir);
@@ -5414,8 +5686,8 @@ function createListCommand2() {
 }
 
 // src/commands/persona/generate.ts
-import { Command as Command49 } from "commander";
-import * as fs22 from "fs";
+import { Command as Command50 } from "commander";
+import * as fs24 from "fs";
 import * as path41 from "path";
 function generatePersonaArtifacts(persona, outputDir, only) {
   const slug = toKebabCase(persona.name);
@@ -5424,8 +5696,8 @@ function generatePersonaArtifacts(persona, outputDir, only) {
     const result = generateRuntime(persona);
     if (result.ok) {
       const outPath = path41.join(outputDir, `${slug}.runtime.json`);
-      fs22.mkdirSync(path41.dirname(outPath), { recursive: true });
-      fs22.writeFileSync(outPath, result.value);
+      fs24.mkdirSync(path41.dirname(outPath), { recursive: true });
+      fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
@@ -5433,7 +5705,7 @@ function generatePersonaArtifacts(persona, outputDir, only) {
     const result = generateAgentsMd(persona);
     if (result.ok) {
       const outPath = path41.join(outputDir, `${slug}.agents.md`);
-      fs22.writeFileSync(outPath, result.value);
+      fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
@@ -5441,15 +5713,15 @@ function generatePersonaArtifacts(persona, outputDir, only) {
     const result = generateCIWorkflow(persona, "github");
     if (result.ok) {
       const outPath = path41.join(outputDir, ".github", "workflows", `${slug}.yml`);
-      fs22.mkdirSync(path41.dirname(outPath), { recursive: true });
-      fs22.writeFileSync(outPath, result.value);
+      fs24.mkdirSync(path41.dirname(outPath), { recursive: true });
+      fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   return generated;
 }
 function createGenerateCommand3() {
-  return new Command49("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) => {
+  return new Command50("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 personaResult = loadPersona(path41.join(resolvePersonasDir(), `${name}.yaml`));
     if (!personaResult.ok) {
@@ -5471,14 +5743,15 @@ function createGenerateCommand3() {
 
 // src/commands/persona/index.ts
 function createPersonaCommand() {
-  const command = new Command50("persona").description("Agent persona management commands");
+  const command = new Command51("persona").description("Agent persona management commands");
   command.addCommand(createListCommand2());
   command.addCommand(createGenerateCommand3());
   return command;
 }
 
 // src/commands/predict.ts
-import { Command as Command51 } from "commander";
+init_dist();
+import { Command as Command52 } from "commander";
 import chalk6 from "chalk";
 var CATEGORY_ORDER = [
   "circular-deps",
@@ -5584,7 +5857,7 @@ function handlePredictError(err, mode) {
   process.exit(ExitCode.ERROR);
 }
 function createPredictCommand() {
-  const command = new Command51("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
+  const command = new Command52("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -5606,8 +5879,137 @@ function createPredictCommand() {
   return command;
 }
 
+// src/commands/publish-analyses.ts
+import * as fs25 from "fs";
+import * as path42 from "path";
+import { Command as Command53 } from "commander";
+init_dist();
+import {
+  renderAnalysisComment,
+  loadPublishedIndex,
+  savePublishedIndex
+} from "@harness-engineering/orchestrator";
+function bootstrapTrackerCommand(opts, verb) {
+  const projectPath = path42.resolve(opts.dir);
+  const trackerConfig = loadTrackerSyncConfig(projectPath);
+  if (!trackerConfig) {
+    logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
+    return null;
+  }
+  if (trackerConfig.kind !== "github") {
+    logger.error(
+      `${verb} currently only supports 'github' tracker kind. Found: ${String(trackerConfig.kind)}`
+    );
+    return null;
+  }
+  const projectEnvPath = path42.join(projectPath, ".env");
+  if (fs25.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+    __require("dotenv").config({ path: projectEnvPath });
+  }
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    logger.error("No GITHUB_TOKEN environment variable found.");
+    return null;
+  }
+  return { token, projectPath, trackerConfig };
+}
+function buildNameToExternalIdMap(projectPath) {
+  const roadmapFile = path42.join(projectPath, "docs", "roadmap.md");
+  if (!fs25.existsSync(roadmapFile)) {
+    logger.error("No docs/roadmap.md found. Cannot map issue hashes to external IDs.");
+    return null;
+  }
+  const { parseRoadmap } = (init_dist(), __toCommonJS(dist_exports));
+  const roadmapParsed = parseRoadmap(fs25.readFileSync(roadmapFile, "utf-8"));
+  if (!roadmapParsed.ok) {
+    logger.error("Failed to parse docs/roadmap.md");
+    return null;
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const milestone of roadmapParsed.value.milestones) {
+    for (const feature of milestone.features) {
+      if (feature.externalId) {
+        map.set(feature.name.toLowerCase(), feature.externalId);
+      }
+    }
+  }
+  return map;
+}
+function resolveExternalId(record, nameToExternalId) {
+  if (record.externalId) return record.externalId;
+  for (const [featName, extId] of nameToExternalId) {
+    const prefix = featName.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 20);
+    if (record.identifier.startsWith(prefix)) return extId;
+  }
+  return null;
+}
+async function publishUnpublishedAnalyses(analyses, adapter, nameToExternalId, publishedIndex) {
+  let publishedCount = 0;
+  for (const record of analyses) {
+    if (publishedIndex[record.issueId]) continue;
+    const externalId = resolveExternalId(record, nameToExternalId);
+    if (!externalId) {
+      logger.dim(`Skipping ${record.identifier}: could not resolve externalId from roadmap`);
+      continue;
+    }
+    logger.info(`Publishing analysis for ${record.identifier} to ${externalId}...`);
+    const result = await adapter.addComment(externalId, renderAnalysisComment(record));
+    if (result.ok) {
+      publishedIndex[record.issueId] = (/* @__PURE__ */ new Date()).toISOString();
+      publishedCount++;
+    } else {
+      logger.error(`Failed to publish ${record.identifier}: ${result.error.message}`);
+    }
+  }
+  return publishedCount;
+}
+async function runPublishAnalyses(opts) {
+  const bootstrap = bootstrapTrackerCommand(opts, "publish");
+  if (!bootstrap) return process.exit(1);
+  const { token, projectPath, trackerConfig } = bootstrap;
+  const nameToExternalId = buildNameToExternalIdMap(projectPath);
+  if (!nameToExternalId) return process.exit(1);
+  const { AnalysisArchive } = await import("@harness-engineering/orchestrator");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-WCSJHQPK.js");
+  const archive = new AnalysisArchive(path42.join(projectPath, ".harness", "analyses"));
+  const analyses = await archive.list();
+  if (analyses.length === 0) {
+    logger.info("No analyses found to publish.");
+    return;
+  }
+  const publishedIndex = loadPublishedIndex(projectPath);
+  const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
+  const publishedCount = await publishUnpublishedAnalyses(
+    analyses,
+    adapter,
+    nameToExternalId,
+    publishedIndex
+  );
+  if (publishedCount > 0) {
+    savePublishedIndex(projectPath, publishedIndex);
+    logger.success(`Successfully published ${publishedCount} analyses.`);
+  } else {
+    logger.info("All analyses are already up to date on external tracker.");
+  }
+}
+function createPublishAnalysesCommand() {
+  const command = new Command53("publish-analyses").description(
+    "Publishes locally generated intelligence analyses to the external issue tracker (e.g., GitHub)"
+  ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
+    try {
+      await runPublishAnalyses(opts);
+    } catch (err) {
+      logger.error(
+        `Error publishing analyses: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
 // src/commands/recommend.ts
-import { Command as Command52 } from "commander";
+import { Command as Command54 } from "commander";
 import chalk7 from "chalk";
 async function resolveSnapshot(cwd, noCache) {
   if (!noCache) {
@@ -5671,7 +6073,7 @@ function printRecommendations(result) {
   console.log("");
 }
 function createRecommendCommand() {
-  const command = new Command52("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
+  const command = new Command54("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -5707,9 +6109,10 @@ function createRecommendCommand() {
 }
 
 // src/commands/scan-config.ts
-import { Command as Command53 } from "commander";
-import { existsSync as existsSync21, readFileSync as readFileSync11, writeFileSync as writeFileSync12 } from "fs";
-import { join as join32, relative as relative2 } from "path";
+init_dist();
+import { Command as Command55 } from "commander";
+import { existsSync as existsSync22, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
+import { join as join30, 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();
@@ -5742,10 +6145,10 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync21(filePath)) return null;
+  if (!existsSync22(filePath)) return null;
   let content;
   try {
-    content = readFileSync11(filePath, "utf8");
+    content = readFileSync14(filePath, "utf8");
   } catch {
     return null;
   }
@@ -5766,7 +6169,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join32(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join30(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -5796,7 +6199,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command53("scan-config").description(
+  const command = new Command55("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 (default: cwd)").option("--fix", "Strip high-severity patterns from files in-place").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -5813,24 +6216,24 @@ function createScanConfigCommand() {
 }
 
 // src/commands/setup.ts
-import { Command as Command54 } from "commander";
-import * as fs24 from "fs";
+import { Command as Command56 } from "commander";
+import * as fs28 from "fs";
 import * as os7 from "os";
-import * as path43 from "path";
-import chalk8 from "chalk";
+import * as path45 from "path";
+import chalk9 from "chalk";
 
 // src/utils/first-run.ts
-import * as fs23 from "fs";
+import * as fs26 from "fs";
 import * as os6 from "os";
-import * as path42 from "path";
-var HARNESS_DIR = path42.join(os6.homedir(), ".harness");
-var MARKER_FILE = path42.join(HARNESS_DIR, ".setup-complete");
+import * as path43 from "path";
+var HARNESS_DIR = path43.join(os6.homedir(), ".harness");
+var MARKER_FILE = path43.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs23.existsSync(MARKER_FILE);
+  return !fs26.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs23.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs23.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs26.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs26.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -5842,6 +6245,119 @@ function printFirstRunWelcome() {
   }
 }
 
+// src/commands/telemetry-wizard.ts
+import * as fs27 from "fs";
+import * as path44 from "path";
+import readline from "readline";
+import chalk8 from "chalk";
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve35) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve35(answer.trim().toLowerCase());
+    });
+  });
+}
+function isNo(answer) {
+  return answer === "n" || answer === "no";
+}
+function isTelemetryConfigured(cwd) {
+  const configPath = path44.join(cwd, "harness.config.json");
+  try {
+    const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+    return raw.telemetry !== void 0 && raw.adoption !== void 0;
+  } catch {
+    return false;
+  }
+}
+function writeTelemetryConfig(cwd, result) {
+  const configPath = path44.join(cwd, "harness.config.json");
+  try {
+    const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+    raw.telemetry = { enabled: result.telemetryEnabled };
+    raw.adoption = { enabled: result.adoptionEnabled };
+    fs27.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+  } catch (err) {
+    console.warn(
+      `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
+  if (hasIdentity) {
+    const harnessDir = path44.join(cwd, ".harness");
+    fs27.mkdirSync(harnessDir, { recursive: true });
+    const telemetryFile = path44.join(harnessDir, "telemetry.json");
+    fs27.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+  }
+}
+async function promptIdentity() {
+  console.log(
+    `  ${chalk8.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
+  );
+  console.log("  Leave blank to keep anonymous.");
+  const answer = await prompt("  Set identity fields? (y/N) ");
+  const identity = {};
+  if (answer === "y" || answer === "yes") {
+    const projectName = await prompt("    Project name: ");
+    if (projectName) identity.project = projectName;
+    const teamName = await prompt("    Team name: ");
+    if (teamName) identity.team = teamName;
+    const alias = await prompt("    Alias: ");
+    if (alias) identity.alias = alias;
+  }
+  return identity;
+}
+async function runTelemetryWizard() {
+  if (!process.stdin.isTTY) return null;
+  console.log("");
+  console.log(`  ${chalk8.bold("Telemetry Configuration")}`);
+  console.log("");
+  console.log("  Harness can collect anonymous usage data to help improve the tool.");
+  console.log("  You can change these settings anytime in harness.config.json.");
+  console.log("");
+  console.log(
+    `  ${chalk8.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
+  );
+  console.log("  No code, file contents, or personally identifiable info is sent.");
+  const telemetryAnswer = await prompt("  Enable anonymous telemetry? (Y/n) ");
+  const telemetryEnabled = !isNo(telemetryAnswer);
+  console.log("");
+  console.log(
+    `  ${chalk8.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
+  );
+  console.log("  Stored locally in .harness/adoption/. Never sent externally.");
+  const adoptionAnswer = await prompt("  Enable local adoption tracking? (Y/n) ");
+  const adoptionEnabled = !isNo(adoptionAnswer);
+  console.log("");
+  const identity = await promptIdentity();
+  return { telemetryEnabled, adoptionEnabled, identity };
+}
+async function ensureTelemetryConfigured(cwd) {
+  const configPath = path44.join(cwd, "harness.config.json");
+  if (!fs27.existsSync(configPath)) {
+    return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
+  }
+  if (isTelemetryConfigured(cwd)) {
+    return { status: "pass", message: "Telemetry already configured" };
+  }
+  const result = await runTelemetryWizard();
+  if (!result) {
+    return { status: "warn", message: "Non-interactive mode \u2014 skipped telemetry configuration" };
+  }
+  writeTelemetryConfig(cwd, result);
+  const parts = [];
+  parts.push(`telemetry ${result.telemetryEnabled ? "enabled" : "disabled"}`);
+  parts.push(`adoption ${result.adoptionEnabled ? "enabled" : "disabled"}`);
+  if (result.identity.project || result.identity.team || result.identity.alias) {
+    parts.push("identity set");
+  }
+  return { status: "pass", message: `Telemetry configured: ${parts.join(", ")}` };
+}
+
 // src/commands/setup.ts
 function checkNodeVersion3() {
   const result = checkNodeVersion();
@@ -5868,7 +6384,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs24.existsSync(path43.join(os7.homedir(), dirName));
+  return fs28.existsSync(path45.join(os7.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -5905,12 +6421,12 @@ async function runMcpSetup(cwd) {
   return results;
 }
 function formatStep(result) {
-  const icon = result.status === "pass" ? chalk8.green("\u2713") : result.status === "warn" ? chalk8.yellow("\u26A0") : chalk8.red("\u2717");
+  const icon = result.status === "pass" ? chalk9.green("\u2713") : result.status === "warn" ? chalk9.yellow("\u26A0") : chalk9.red("\u2717");
   return `  ${icon} ${result.message}`;
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path43.join(cwd, ".mcp.json");
+    const mcpPath = path45.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -5919,9 +6435,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path43.join(cwd, ".gemini");
-    if (fs24.existsSync(geminiDir)) {
-      const geminiPath = path43.join(geminiDir, "settings.json");
+    const geminiDir = path45.join(cwd, ".gemini");
+    if (fs28.existsSync(geminiDir)) {
+      const geminiPath = path45.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -5941,6 +6457,44 @@ function configureTier0Integrations(cwd) {
     return { status: "fail", message: `Tier 0 integration configuration failed \u2014 ${msg}` };
   }
 }
+function ensureHooks(cwd) {
+  const configPath = path45.join(cwd, "harness.config.json");
+  if (!fs28.existsSync(configPath)) {
+    return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
+  }
+  let profile = "standard";
+  const profilePath = path45.join(cwd, ".harness", "hooks", "profile.json");
+  try {
+    const data = JSON.parse(fs28.readFileSync(profilePath, "utf-8"));
+    if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
+      profile = data.profile;
+    }
+  } catch {
+  }
+  try {
+    const result = initHooks({ profile, projectDir: cwd });
+    return {
+      status: "pass",
+      message: `Installed ${result.copiedScripts.length} hooks (${profile} profile)`
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { status: "warn", message: `Hook installation skipped \u2014 ${msg}` };
+  }
+}
+async function runInitialGraphScan(cwd) {
+  try {
+    const { runScan: runScan2 } = await import("./scan-MPJ6JHUY.js");
+    const result = await runScan2(cwd);
+    return {
+      status: "pass",
+      message: `Built knowledge graph: ${result.nodeCount} nodes, ${result.edgeCount} edges`
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { status: "warn", message: `Knowledge graph creation skipped \u2014 ${msg}` };
+  }
+}
 async function runSetup(cwd) {
   const steps = [];
   const nodeResult = checkNodeVersion3();
@@ -5954,6 +6508,12 @@ async function runSetup(cwd) {
   steps.push(...mcpResults);
   const tier0Result = configureTier0Integrations(cwd);
   steps.push(tier0Result);
+  const hooksResult = ensureHooks(cwd);
+  steps.push(hooksResult);
+  const telemetryResult = await ensureTelemetryConfigured(cwd);
+  steps.push(telemetryResult);
+  const graphResult = await runInitialGraphScan(cwd);
+  steps.push(graphResult);
   const success = steps.every((s) => s.status !== "fail");
   if (success) {
     markSetupComplete();
@@ -5961,10 +6521,10 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command54("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command56("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
-    console.log(`  ${chalk8.bold("harness setup")}`);
+    console.log(`  ${chalk9.bold("harness setup")}`);
     console.log("");
     const { steps, success } = await runSetup(cwd);
     for (const step of steps) {
@@ -5983,15 +6543,16 @@ function createSetupCommand() {
 }
 
 // src/commands/share.ts
-import { Command as Command55 } from "commander";
-import * as fs25 from "fs";
-import * as path44 from "path";
+init_dist();
+import { Command as Command57 } from "commander";
+import * as fs29 from "fs";
+import * as path46 from "path";
 import { parse as parseYaml } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path44.resolve(projectPath);
-  const manifestPath = path44.join(rootDir, MANIFEST_FILENAME);
-  if (!fs25.existsSync(manifestPath)) {
+  const rootDir = path46.resolve(projectPath);
+  const manifestPath = path46.join(rootDir, MANIFEST_FILENAME);
+  if (!fs29.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -6000,7 +6561,7 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs25.readFileSync(manifestPath, "utf-8");
+    const raw = fs29.readFileSync(manifestPath, "utf-8");
     parsed = parseYaml(raw);
   } catch (err) {
     logger.error(
@@ -6014,7 +6575,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path44.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);
@@ -6032,8 +6593,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path44.resolve(options.output);
-  const outputPath = path44.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}`);
@@ -6042,28 +6603,28 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command55("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) => {
+  return new Command57("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) => {
     await runShareAction(projectPath, options);
   });
 }
 
 // src/commands/skill/index.ts
-import { Command as Command63 } from "commander";
+import { Command as Command65 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command56 } from "commander";
-import * as fs26 from "fs";
-import * as path45 from "path";
+import { Command as Command58 } from "commander";
+import * as fs30 from "fs";
+import * as path47 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs26.existsSync(dirPath)) return [];
-  const entries = fs26.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs30.existsSync(dirPath)) return [];
+  const entries = fs30.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path45.join(dirPath, name, "skill.yaml");
-    if (!fs26.existsSync(yamlPath)) continue;
+    const yamlPath = path47.join(dirPath, name, "skill.yaml");
+    if (!fs30.existsSync(yamlPath)) continue;
     try {
-      const raw = fs26.readFileSync(yamlPath, "utf-8");
+      const raw = fs30.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -6081,10 +6642,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path45.dirname(globalDir);
-  const communityBase = path45.join(skillsDir, "community");
-  const communityPlatformDir = path45.join(communityBase, "claude-code");
-  const lockfilePath = path45.join(communityBase, "skills-lock.json");
+  const skillsDir = path47.dirname(globalDir);
+  const communityBase = path47.join(skillsDir, "community");
+  const communityPlatformDir = path47.join(communityBase, "claude-code");
+  const lockfilePath = path47.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -6154,7 +6715,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command56("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
+  return new Command58("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skills = collectSkills({ filter: resolveFilter(opts) });
     if (globalOpts.json) {
@@ -6169,9 +6730,9 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command57 } from "commander";
-import * as fs27 from "fs";
-import * as path46 from "path";
+import { Command as Command59 } from "commander";
+import * as fs31 from "fs";
+import * as path48 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -6267,10 +6828,10 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path46.join(skillDir, "skill.yaml");
-  if (!fs27.existsSync(yamlPath)) return null;
+  const yamlPath = path48.join(skillDir, "skill.yaml");
+  if (!fs31.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs27.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs31.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -6282,22 +6843,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path46.join(projectPath, "docs", "principles.md");
-  return fs27.existsSync(principlesPath) ? fs27.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path48.join(projectPath, "docs", "principles.md");
+  return fs31.existsSync(principlesPath) ? fs31.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs27.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs27.statSync(path46.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs27.readFileSync(path46.join(dirPath, files[0].name), "utf-8");
+  const files = fs31.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs31.statSync(path48.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs31.readFileSync(path48.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 = path46.join(projectPath, stateFilePath);
-    if (!fs27.existsSync(fullPath)) continue;
-    const stat = fs27.statSync(fullPath);
+    const fullPath = path48.join(projectPath, stateFilePath);
+    if (!fs31.existsSync(fullPath)) continue;
+    const stat = fs31.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs27.readFileSync(fullPath, "utf-8");
+    return fs31.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -6317,9 +6878,9 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const stateFile = path46.join(projectPath, ".harness", "state.json");
-  if (!fs27.existsSync(stateFile)) return content;
-  const stateContent = fs27.readFileSync(stateFile, "utf-8");
+  const stateFile = path48.join(projectPath, ".harness", "state.json");
+  if (!fs31.existsSync(stateFile)) return content;
+  const stateContent = fs31.readFileSync(stateFile, "utf-8");
   return content + `
 
 ---
@@ -6331,14 +6892,14 @@ ${stateContent}
 }
 async function runSkill(name, opts) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path46.join(skillsDir, name);
-  if (!fs27.existsSync(skillDir)) {
+  const skillDir = path48.join(skillsDir, name);
+  if (!fs31.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path46.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path48.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -6365,14 +6926,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path46.join(skillDir, "SKILL.md");
-  if (!fs27.existsSync(skillMdPath)) {
+  const skillMdPath = path48.join(skillDir, "SKILL.md");
+  if (!fs31.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = appendProjectState(
-    fs27.readFileSync(skillMdPath, "utf-8"),
+    fs31.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -6381,13 +6942,13 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand2() {
-  return new Command57("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) => runSkill(name, opts));
+  return new Command59("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) => runSkill(name, opts));
 }
 
 // src/commands/skill/validate.ts
-import { Command as Command58 } from "commander";
-import * as fs28 from "fs";
-import * as path47 from "path";
+import { Command as Command60 } from "commander";
+import * as fs32 from "fs";
+import * as path49 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -6399,11 +6960,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs28.existsSync(skillMdPath)) {
+  if (!fs32.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs28.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs32.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -6428,20 +6989,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path47.join(skillsDir, name);
-  const yamlPath = path47.join(skillDir, "skill.yaml");
-  if (!fs28.existsSync(yamlPath)) {
+  const skillDir = path49.join(skillsDir, name);
+  const yamlPath = path49.join(skillDir, "skill.yaml");
+  if (!fs32.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs28.readFileSync(yamlPath, "utf-8");
+    const raw = fs32.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, path47.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path49.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)}`);
@@ -6449,15 +7010,15 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command58("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command60("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs28.existsSync(skillsDir)) {
+    if (!fs32.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs28.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs32.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -6479,24 +7040,24 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command59 } from "commander";
-import * as fs29 from "fs";
-import * as path48 from "path";
+import { Command as Command61 } from "commander";
+import * as fs33 from "fs";
+import * as path50 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path48.join(skillsDir, name);
-  if (!fs29.existsSync(skillDir)) {
+  const skillDir = path50.join(skillsDir, name);
+  if (!fs33.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path48.join(skillDir, "skill.yaml");
-  if (!fs29.existsSync(yamlPath)) {
+  const yamlPath = path50.join(skillDir, "skill.yaml");
+  if (!fs33.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs29.readFileSync(yamlPath, "utf-8");
+    const raw = fs33.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -6525,7 +7086,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command59("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command61("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 loaded = loadSkillMetadata2(name);
     if (!loaded.ok) {
@@ -6542,7 +7103,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command60 } from "commander";
+import { Command as Command62 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -6587,15 +7148,15 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand() {
-  return new Command60("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
+  return new Command62("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
     await runSearchAction(query, opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/skill/create.ts
-import { Command as Command61 } from "commander";
-import * as path49 from "path";
-import * as fs30 from "fs";
+import { Command as Command63 } from "commander";
+import * as path51 from "path";
+import * as fs34 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -6679,22 +7240,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 ?? path49.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path49.join(baseDir, name);
-  if (fs30.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path51.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path51.join(baseDir, name);
+  if (fs34.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs30.mkdirSync(skillDir, { recursive: true });
+  fs34.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path49.join(skillDir, "skill.yaml");
-  fs30.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path51.join(skillDir, "skill.yaml");
+  fs34.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path49.join(skillDir, "SKILL.md");
-  fs30.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path51.join(skillDir, "SKILL.md");
+  fs34.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path49.join(skillDir, "README.md");
-  fs30.writeFileSync(readmePath, readme);
+  const readmePath = path51.join(skillDir, "README.md");
+  fs34.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -6708,12 +7269,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path49.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path51.join(result.directory, "SKILL.md")} with your skill content`);
   logger.info(`  2. Run: harness skill validate ${name}`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  return new Command61("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
+  return new Command63("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = runCreate(name, {
@@ -6736,26 +7297,26 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command62 } from "commander";
-import * as fs32 from "fs";
-import * as path51 from "path";
+import { Command as Command64 } from "commander";
+import * as fs36 from "fs";
+import * as path53 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs31 from "fs";
-import * as path50 from "path";
+import * as fs35 from "fs";
+import * as path52 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path50.join(skillDir, "skill.yaml");
-  if (!fs31.existsSync(skillYamlPath)) {
+  const skillYamlPath = path52.join(skillDir, "skill.yaml");
+  if (!fs35.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs31.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs35.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -6777,11 +7338,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 = path50.join(skillDir, "SKILL.md");
-  if (!fs31.existsSync(skillMdPath)) {
+  const skillMdPath = path52.join(skillDir, "SKILL.md");
+  if (!fs35.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs31.readFileSync(skillMdPath, "utf-8");
+    const content = fs35.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -6861,11 +7422,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path51.join(skillDir, "package.json");
-  fs32.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path51.join(skillDir, "README.md");
-  if (!fs32.existsSync(readmePath)) {
-    const skillMdContent = fs32.readFileSync(path51.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path53.join(skillDir, "package.json");
+  fs36.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path53.join(skillDir, "README.md");
+  if (!fs36.existsSync(readmePath)) {
+    const skillMdContent = fs36.readFileSync(path53.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -6879,7 +7440,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs32.writeFileSync(readmePath, readme);
+    fs36.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -6905,7 +7466,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command62("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
+  return new Command64("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillDir = opts.dir || process.cwd();
     try {
@@ -6930,7 +7491,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command63("skill").description("Skill management commands");
+  const command = new Command65("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand2());
   command.addCommand(createValidateCommand2());
@@ -6942,9 +7503,10 @@ function createSkillCommand() {
 }
 
 // src/commands/snapshot.ts
-import { Command as Command64 } from "commander";
+init_dist();
+import { Command as Command66 } from "commander";
 import { execSync as execSync5 } from "child_process";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function getCommitHash3(cwd) {
   try {
     return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
@@ -6969,9 +7531,9 @@ function formatDelta(delta) {
 function directionSymbol(direction) {
   switch (direction) {
     case "improving":
-      return chalk9.green("improving");
+      return chalk10.green("improving");
     case "declining":
-      return chalk9.red("declining");
+      return chalk10.red("declining");
     case "stable":
       return "=";
   }
@@ -7124,7 +7686,7 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command64("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command66("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand(command);
@@ -7132,11 +7694,12 @@ function createSnapshotCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command69 } from "commander";
+import { Command as Command71 } from "commander";
 
 // src/commands/state/show.ts
-import { Command as Command65 } from "commander";
-import * as path52 from "path";
+init_dist();
+import { Command as Command67 } from "commander";
+import * as path54 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -7160,9 +7723,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command65("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
+  return new Command67("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 result = await loadState(path52.resolve(opts.path), opts.stream);
+    const result = await loadState(path54.resolve(opts.path), opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -7177,10 +7740,11 @@ function createShowCommand() {
 }
 
 // src/commands/state/reset.ts
-import { Command as Command66 } from "commander";
-import * as fs33 from "fs";
-import * as path53 from "path";
-import * as readline from "readline";
+init_dist();
+import { Command as Command68 } from "commander";
+import * as fs37 from "fs";
+import * as path55 from "path";
+import * as readline2 from "readline";
 async function resolveStatePath(projectPath, stream) {
   if (stream) {
     const streamResult = await resolveStreamPath(projectPath, { stream });
@@ -7188,22 +7752,22 @@ async function resolveStatePath(projectPath, stream) {
       logger.error(streamResult.error.message);
       process.exit(ExitCode.ERROR);
     }
-    return path53.join(streamResult.value, "state.json");
+    return path55.join(streamResult.value, "state.json");
   }
-  return path53.join(projectPath, ".harness", "state.json");
+  return path55.join(projectPath, ".harness", "state.json");
 }
 async function confirmReset() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve33) => {
-    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve33);
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve35) => {
+    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve35);
   });
   rl.close();
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path53.resolve(opts.path);
+  const projectPath = path55.resolve(opts.path);
   const statePath = await resolveStatePath(projectPath, opts.stream);
-  if (!fs33.existsSync(statePath)) {
+  if (!fs37.existsSync(statePath)) {
     logger.info("No state file found. Nothing to reset.");
     process.exit(ExitCode.SUCCESS);
   }
@@ -7212,7 +7776,7 @@ async function runReset(opts) {
     process.exit(ExitCode.SUCCESS);
   }
   try {
-    fs33.unlinkSync(statePath);
+    fs37.unlinkSync(statePath);
     logger.success("Project state reset.");
   } catch (e) {
     logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -7221,15 +7785,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command66("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) => runReset(opts));
+  return new Command68("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) => runReset(opts));
 }
 
 // src/commands/state/learn.ts
-import { Command as Command67 } from "commander";
-import * as path54 from "path";
+init_dist();
+import { Command as Command69 } from "commander";
+import * as path56 from "path";
 function createLearnCommand() {
-  return new Command67("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 = path54.resolve(opts.path);
+  return new Command69("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 = path56.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -7242,10 +7807,11 @@ function createLearnCommand() {
 }
 
 // src/commands/state/streams.ts
-import { Command as Command68 } from "commander";
-import * as path55 from "path";
+init_dist();
+import { Command as Command70 } from "commander";
+import * as path57 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path55.resolve(opts.path);
+  const projectPath = path57.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -7266,7 +7832,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path55.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path57.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7275,7 +7841,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path55.resolve(opts.path), name);
+  const result = await archiveStream(path57.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7284,7 +7850,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path55.resolve(opts.path), name);
+  const result = await setActiveStream(path57.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7293,7 +7859,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command68("streams").description("Manage state streams");
+  const command = new Command70("streams").description("Manage state streams");
   command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => runListStreams(opts, cmd.optsWithGlobals()));
   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) => runCreateStream(name, opts));
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => runArchiveStream(name, opts));
@@ -7303,7 +7869,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command69("state").description("Project state management commands");
+  const command = new Command71("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -7311,8 +7877,154 @@ function createStateCommand() {
   return command;
 }
 
+// src/commands/sync-analyses.ts
+import * as fs38 from "fs";
+import * as path58 from "path";
+import { Command as Command72 } from "commander";
+init_dist();
+function isValidRecord(record) {
+  return typeof record.issueId === "string" && !!record.issueId && typeof record.identifier === "string" && !!record.identifier && typeof record.analyzedAt === "string" && !/[/\\]/.test(record.issueId);
+}
+function extractAnalysisFromComments(comments) {
+  const sorted = [...comments].sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  for (const comment of sorted) {
+    const fenceRegex = /```json\s*\r?\n([\s\S]*?)\r?\n```/g;
+    let match;
+    while ((match = fenceRegex.exec(comment.body)) !== null) {
+      try {
+        const parsed = JSON.parse(match[1]);
+        if (parsed._harness_analysis !== true) continue;
+        const { _harness_analysis, _version, ...record } = parsed;
+        if (isValidRecord(record)) return record;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function bootstrapTrackerCommand2(opts, verb) {
+  const projectPath = path58.resolve(opts.dir);
+  const trackerConfig = loadTrackerSyncConfig(projectPath);
+  if (!trackerConfig) {
+    logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
+    return null;
+  }
+  if (trackerConfig.kind !== "github") {
+    logger.error(
+      `${verb} currently only supports 'github' tracker kind. Found: ${String(trackerConfig.kind)}`
+    );
+    return null;
+  }
+  const projectEnvPath = path58.join(projectPath, ".env");
+  if (fs38.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+    __require("dotenv").config({ path: projectEnvPath });
+  }
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    logger.error("No GITHUB_TOKEN environment variable found.");
+    return null;
+  }
+  return { token, projectPath, trackerConfig };
+}
+function loadRoadmapFeatures(projectPath) {
+  const roadmapFile = path58.join(projectPath, "docs", "roadmap.md");
+  if (!fs38.existsSync(roadmapFile)) {
+    logger.error("No docs/roadmap.md found. Cannot discover features with externalIds.");
+    return null;
+  }
+  const { parseRoadmap } = (init_dist(), __toCommonJS(dist_exports));
+  const roadmapParsed = parseRoadmap(fs38.readFileSync(roadmapFile, "utf-8"));
+  if (!roadmapParsed.ok) {
+    logger.error("Failed to parse docs/roadmap.md");
+    return null;
+  }
+  const features = [];
+  for (const milestone of roadmapParsed.value.milestones) {
+    for (const feature of milestone.features) {
+      if (feature.externalId) {
+        features.push({ name: feature.name, externalId: feature.externalId });
+      }
+    }
+  }
+  return features;
+}
+async function syncFeatureAnalyses(features, adapter, archive, publishedIndex) {
+  let syncedCount = 0;
+  let skippedCount = 0;
+  let warnCount = 0;
+  for (const { name, externalId } of features) {
+    const commentsResult = await adapter.fetchComments(externalId);
+    if (!commentsResult.ok) {
+      logger.warn(
+        `Failed to fetch comments for "${name}" (${externalId}): ${commentsResult.error.message}`
+      );
+      warnCount++;
+      continue;
+    }
+    const record = extractAnalysisFromComments(commentsResult.value);
+    if (!record) {
+      skippedCount++;
+      continue;
+    }
+    await archive.save(record);
+    publishedIndex[record.issueId] = record.analyzedAt;
+    syncedCount++;
+    logger.info(`Synced analysis for "${name}" (${record.identifier})`);
+  }
+  return { syncedCount, skippedCount, warnCount };
+}
+async function runSyncAnalyses(opts) {
+  const bootstrap = bootstrapTrackerCommand2(opts, "sync");
+  if (!bootstrap) return process.exit(1);
+  const { token, projectPath, trackerConfig } = bootstrap;
+  const features = loadRoadmapFeatures(projectPath);
+  if (!features) return process.exit(1);
+  if (features.length === 0) {
+    logger.info("No roadmap features have externalIds. Nothing to sync.");
+    return;
+  }
+  const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-WCSJHQPK.js");
+  const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
+  const archive = new AnalysisArchive(path58.join(projectPath, ".harness", "analyses"));
+  const publishedIndex = loadPublishedIndex2(projectPath);
+  const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
+    features,
+    adapter,
+    archive,
+    publishedIndex
+  );
+  if (syncedCount > 0) {
+    savePublishedIndex2(projectPath, publishedIndex);
+    logger.success(
+      `Synced ${syncedCount} analysis record(s). Skipped ${skippedCount} (no analysis). Warnings: ${warnCount}.`
+    );
+  } else {
+    logger.info(
+      `No new analyses found on tracker. Skipped ${skippedCount} feature(s) with no analysis comments.`
+    );
+  }
+}
+function createSyncAnalysesCommand() {
+  const command = new Command72("sync-analyses").description(
+    "Pull published intelligence analyses from the external issue tracker into the local .harness/analyses/ directory"
+  ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
+    try {
+      await runSyncAnalyses(opts);
+    } catch (err) {
+      logger.error(`Error syncing analyses: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
 // src/commands/taint.ts
-import { Command as Command70 } from "commander";
+init_dist();
+import { Command as Command73 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -7384,27 +8096,28 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command70("taint").description("Manage sentinel session taint state");
+  const taint = new Command73("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command73 } from "commander";
+import { Command as Command76 } from "commander";
 
 // src/commands/telemetry/identify.ts
-import { Command as Command71 } from "commander";
-import * as fs34 from "fs";
-import * as path56 from "path";
+init_dist();
+import { Command as Command74 } from "commander";
+import * as fs39 from "fs";
+import * as path59 from "path";
 function telemetryFilePath(cwd) {
-  return path56.join(cwd, ".harness", "telemetry.json");
+  return path59.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path56.dirname(filePath);
-  fs34.mkdirSync(dir, { recursive: true });
-  fs34.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path59.dirname(filePath);
+  fs39.mkdirSync(dir, { recursive: true });
+  fs39.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -7418,7 +8131,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command71("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
+  const cmd = new Command74("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
     const cwd = process.cwd();
     if (opts.clear) {
       writeTelemetryFile(cwd, { identity: {} });
@@ -7442,7 +8155,8 @@ function createIdentifyCommand() {
 }
 
 // src/commands/telemetry/status.ts
-import { Command as Command72 } from "commander";
+init_dist();
+import { Command as Command75 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -7480,7 +8194,7 @@ function printHumanStatus(result) {
   }
 }
 function createStatusCommand() {
-  const cmd = new Command72("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command75("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
     const cwd = process.cwd();
     const envOverrides = gatherEnvOverrides();
     const consent = resolveConsent(cwd, void 0);
@@ -7513,15 +8227,15 @@ function createStatusCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command73("telemetry").description("Telemetry identity and status management");
+  const command = new Command76("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   return command;
 }
 
 // src/commands/traceability.ts
-import { Command as Command74 } from "commander";
-import chalk10 from "chalk";
+import { Command as Command77 } from "commander";
+import chalk11 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
   if (maxConfidence > 0) return "inferred";
@@ -7530,13 +8244,13 @@ function confidenceLabel(maxConfidence) {
 function statusIcon(status) {
   switch (status) {
     case "full":
-      return chalk10.green("\u2713 full");
+      return chalk11.green("\u2713 full");
     case "code-only":
-      return chalk10.yellow("\u25D0 code-only");
+      return chalk11.yellow("\u25D0 code-only");
     case "test-only":
-      return chalk10.yellow("\u25D0 test-only");
+      return chalk11.yellow("\u25D0 test-only");
     case "none":
-      return chalk10.red("\u2717 none");
+      return chalk11.red("\u2717 none");
     default:
       return status;
   }
@@ -7578,14 +8292,14 @@ function handleEmptyResults(mode) {
 }
 function printResultTable(result, mode) {
   const specLabel = result.specPath || result.featureName || "Unknown";
-  console.log(`  ${chalk10.cyan(specLabel)} ${chalk10.dim(`(${result.summary.total} requirements)`)}`);
+  console.log(`  ${chalk11.cyan(specLabel)} ${chalk11.dim(`(${result.summary.total} requirements)`)}`);
   console.log("");
   const numWidth = 4;
   const nameWidth = mode === OutputMode.VERBOSE ? 44 : 36;
   const codeWidth = 6;
   const testWidth = 7;
   const confWidth = 12;
-  const header = chalk10.dim(
+  const header = chalk11.dim(
     `  ${pad("#", numWidth)}${pad("Requirement", nameWidth)}${pad("Code", codeWidth)}${pad("Tests", testWidth)}${pad("Confidence", confWidth)}Status`
   );
   console.log(header);
@@ -7614,10 +8328,10 @@ function printRequirementRows(requirements, mode, cols) {
     );
     if (mode === OutputMode.VERBOSE) {
       for (const f of req.codeFiles) {
-        console.log(chalk10.dim(`        code: ${f.path} (${f.method})`));
+        console.log(chalk11.dim(`        code: ${f.path} (${f.method})`));
       }
       for (const f of req.testFiles) {
-        console.log(chalk10.dim(`        test: ${f.path} (${f.method})`));
+        console.log(chalk11.dim(`        test: ${f.path} (${f.method})`));
       }
     }
   }
@@ -7628,7 +8342,7 @@ function printCoverageSummary(summary) {
   const codePct = s.total > 0 ? Math.round(s.withCode / s.total * 100) : 0;
   const testPct = s.total > 0 ? Math.round(s.withTests / s.total * 100) : 0;
   console.log(
-    `  ${chalk10.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
+    `  ${chalk11.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
   );
 }
 async function runTraceability(options) {
@@ -7636,7 +8350,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore(mode);
-  const graphModule = await import("./dist-QW5G3GX3.js");
+  const graphModule = await import("./dist-RADHOOXG.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -7644,14 +8358,14 @@ async function runTraceability(options) {
     console.log(JSON.stringify(results, null, 2));
   } else {
     console.log("");
-    console.log(chalk10.bold("Spec-to-Implementation Traceability"));
+    console.log(chalk11.bold("Spec-to-Implementation Traceability"));
     console.log("");
     for (const result of results) printResultTable(result, mode);
   }
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command74("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
+  return new Command77("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     await runTraceability({
       spec: opts.spec,
@@ -7664,15 +8378,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path57 from "path";
-import { Command as Command75 } from "commander";
+import * as path60 from "path";
+import { Command as Command78 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path57.dirname(globalDir);
-  const communityBase = path57.join(skillsDir, "community");
-  const lockfilePath = path57.join(communityBase, "skills-lock.json");
+  const skillsDir = path60.dirname(globalDir);
+  const communityBase = path60.join(skillsDir, "community");
+  const lockfilePath = path60.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -7702,7 +8416,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command75("uninstall");
+  const cmd = new Command78("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);
@@ -7721,9 +8435,10 @@ function createUninstallCommand() {
 }
 
 // src/commands/uninstall-constraints.ts
-import * as fs35 from "fs/promises";
-import * as path58 from "path";
-import { Command as Command76 } from "commander";
+init_dist();
+import * as fs40 from "fs/promises";
+import * as path61 from "path";
+import { Command as Command79 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -7743,7 +8458,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs35.readFile(configPath, "utf-8");
+    const raw = await fs40.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -7780,11 +8495,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command76("uninstall-constraints");
+  const cmd = new Command79("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 = path58.resolve(opts.config);
+      configPath = path61.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -7793,8 +8508,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path58.dirname(configPath);
-    const lockfilePath = path58.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path61.dirname(configPath);
+    const lockfilePath = path61.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -7819,12 +8534,13 @@ function createUninstallConstraintsCommand() {
 }
 
 // src/commands/update.ts
-import { Command as Command77 } from "commander";
+import { Command as Command80 } from "commander";
 import { execFile, execFileSync as execFileSync6 } from "child_process";
-import { realpathSync } from "fs";
+import { realpathSync, existsSync as existsSync36, readFileSync as readFileSync25 } from "fs";
+import { join as join47 } from "path";
 import { promisify } from "util";
-import readline2 from "readline";
-import chalk11 from "chalk";
+import readline3 from "readline";
+import chalk12 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -7882,23 +8598,64 @@ function getInstalledPackages(pm) {
     return ["@harness-engineering/cli", "@harness-engineering/core"];
   }
 }
-function prompt(question) {
-  const rl = readline2.createInterface({
+function prompt2(question) {
+  const rl = readline3.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve33) => {
+  return new Promise((resolve35) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve33(answer.trim().toLowerCase());
+      resolve35(answer.trim().toLowerCase());
     });
   });
 }
+async function ensureTelemetryIfNeeded() {
+  const cwd = process.cwd();
+  const result = await ensureTelemetryConfigured(cwd);
+  if (result.status === "pass") {
+    logger.success(result.message);
+  } else if (result.status === "warn") {
+    logger.warn(result.message);
+  }
+}
+function refreshHooks() {
+  const cwd = process.cwd();
+  const configPath = join47(cwd, "harness.config.json");
+  if (!existsSync36(configPath)) return;
+  let profile = "standard";
+  const profilePath = join47(cwd, ".harness", "hooks", "profile.json");
+  try {
+    const data = JSON.parse(readFileSync25(profilePath, "utf-8"));
+    if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
+      profile = data.profile;
+    }
+  } catch {
+  }
+  try {
+    const result = initHooks({ profile, projectDir: cwd });
+    logger.success(`Refreshed ${result.copiedScripts.length} hooks (${profile} profile)`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Hook refresh failed: ${msg}`);
+  }
+}
+function runLocalGraphScan() {
+  try {
+    logger.info("Scanning codebase to rebuild knowledge graph...");
+    execFileSync6("harness", ["graph", "scan", "."], { stdio: "inherit" });
+  } catch {
+    logger.warn("Graph scan failed. Run manually:");
+    console.log(`  ${chalk12.cyan("harness graph scan .")}`);
+  }
+}
 async function offerRegeneration() {
   console.log("");
-  const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (Y/n) ");
+  const regenAnswer = await prompt2(
+    "Regenerate slash commands, agent definitions, and knowledge graph? (Y/n) "
+  );
   if (regenAnswer === "n" || regenAnswer === "no") return;
-  const scopeAnswer = await prompt("Generate for (G)lobal or (l)ocal project? (G/l) ");
+  const scopeAnswer = await prompt2("Generate for (G)lobal or (l)ocal project? (G/l) ");
   const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
   try {
     execFileSync6("harness", ["generate", ...isGlobal ? ["--global"] : []], {
@@ -7906,7 +8663,10 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk11.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk12.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+  }
+  if (!isGlobal) {
+    runLocalGraphScan();
   }
 }
 async function checkAllPackages(packages, installedVersions) {
@@ -7958,14 +8718,16 @@ async function runUpdateAction(opts, globalOpts) {
     const { hasUpdates, outdated } = await checkAllPackages(packages, installedVersions);
     if (!hasUpdates) {
       logger.success("All packages are up to date");
+      refreshHooks();
+      await ensureTelemetryIfNeeded();
       await offerRegeneration();
       process.exit(ExitCode.SUCCESS);
     }
     console.log("");
     for (const { pkg, current, latest } of outdated) {
       const shortName = pkg.replace("@harness-engineering/", "");
-      const currentStr = current ? chalk11.dim(`v${current}`) : chalk11.dim("not installed");
-      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk11.green(`v${latest}`)}`);
+      const currentStr = current ? chalk12.dim(`v${current}`) : chalk12.dim("not installed");
+      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk12.green(`v${latest}`)}`);
     }
     console.log("");
   }
@@ -7981,14 +8743,16 @@ async function runUpdateAction(opts, globalOpts) {
   } catch {
     console.log("");
     logger.error("Update failed. You can try manually:");
-    console.log(`  ${chalk11.cyan(installCmd)}`);
+    console.log(`  ${chalk12.cyan(installCmd)}`);
     process.exit(ExitCode.ERROR);
   }
+  refreshHooks();
+  await ensureTelemetryIfNeeded();
   await offerRegeneration();
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command77("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
+  return new Command80("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
     "--regenerate",
     "Only regenerate slash commands and agent definitions (skip package updates)"
   ).action(async (opts, cmd) => {
@@ -7998,15 +8762,15 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command78 } from "commander";
+import { Command as Command81 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-TZQUURSP.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-WCSJHQPK.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
     records.push(...ccRecords);
   }
-  if (records.length === 0) return records;
+  if (records.length === 0) return { records, pricingData: null };
   const pricingData = await loadPricingData(cwd);
   for (const record of records) {
     if (record.model && record.costMicroUSD == null) {
@@ -8014,7 +8778,14 @@ async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
       if (cost != null) record.costMicroUSD = cost;
     }
   }
-  return records;
+  return { records, pricingData };
+}
+function computeCacheSavings(cacheReadTokens, model, pricingData) {
+  if (!cacheReadTokens || !model || !pricingData) return null;
+  const pricing = pricingData.get(model);
+  if (!pricing || pricing.cacheReadPer1M == null) return null;
+  const savingsUSD = cacheReadTokens / 1e6 * (pricing.inputPer1M - pricing.cacheReadPer1M);
+  return Math.round(savingsUSD * 1e6);
 }
 function formatMicroUSD(microUSD) {
   if (microUSD == null) return "N/A";
@@ -8042,7 +8813,10 @@ function registerDailyCommand(usage) {
     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);
+    const { records, pricingData } = await loadAndPriceRecords(
+      cwd,
+      globalOpts.includeClaudeSessions
+    );
     if (records.length === 0) {
       if (globalOpts.json) {
         console.log(JSON.stringify([]));
@@ -8051,23 +8825,25 @@ function registerDailyCommand(usage) {
       }
       return;
     }
-    const { aggregateByDay } = await import("./dist-TZQUURSP.js");
+    const { aggregateByDay } = await import("./dist-WCSJHQPK.js");
     const dailyData = aggregateByDay(records);
     const limited = dailyData.slice(0, days);
     if (globalOpts.json) {
       const enriched = limited.map((day) => {
         const hitRate = computeCacheHitRate(day.cacheReadTokens, day.tokens.inputTokens);
+        const savings = computeCacheSavings(day.cacheReadTokens, day.models[0], pricingData);
         return {
           ...day,
-          ...hitRate != null ? { cacheHitRate: Math.round(hitRate * 1e3) / 1e3 } : {}
+          ...hitRate != null ? { cacheHitRate: Math.round(hitRate * 1e3) / 1e3 } : {},
+          ...savings != null ? { cacheSavingsMicroUSD: savings } : {}
         };
       });
       console.log(JSON.stringify(enriched, null, 2));
       return;
     }
     const hasCacheData = limited.some((d) => d.cacheReadTokens != null && d.cacheReadTokens > 0);
-    const cacheHeader = hasCacheData ? " | Cache " : "";
-    const cacheDivider = hasCacheData ? " | ------" : "";
+    const cacheHeader = hasCacheData ? " | Cache  | Saved  " : "";
+    const cacheDivider = hasCacheData ? " | ------ | -------" : "";
     const header = "Date         | Sessions | Input     | Output    | Model(s)                     | Cost  " + cacheHeader;
     const divider = "-------------|----------|-----------|-----------|------------------------------|-------" + cacheDivider;
     logger.info(header);
@@ -8081,7 +8857,10 @@ function registerDailyCommand(usage) {
       const cost = formatMicroUSD(day.costMicroUSD);
       const cacheCol = hasCacheData ? (() => {
         const rate = computeCacheHitRate(day.cacheReadTokens, day.tokens.inputTokens);
-        return " | " + (rate != null ? formatPercent(rate).padStart(5) : "    -");
+        const savings = computeCacheSavings(day.cacheReadTokens, day.models[0], pricingData);
+        const rateStr = rate != null ? formatPercent(rate).padStart(5) : "    -";
+        const savingsStr = savings != null ? formatMicroUSD(savings).padStart(7) : "    N/A";
+        return " | " + rateStr + " | " + savingsStr;
       })() : "";
       logger.info(
         `${date} | ${sessions} | ${input} | ${output} | ${models} | ${cost}${cacheCol}`
@@ -8094,7 +8873,7 @@ function registerSessionsCommand(usage) {
     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);
+    const { records } = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
     if (records.length === 0) {
       if (globalOpts.json) {
         console.log(JSON.stringify([]));
@@ -8103,7 +8882,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-TZQUURSP.js");
+    const { aggregateBySession } = await import("./dist-WCSJHQPK.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -8145,7 +8924,7 @@ function reportSessionNotFound(id, sessionData, useJson) {
     }
   }
 }
-function printSessionDetail(match) {
+function printSessionDetail(match, pricingData) {
   logger.info(`Session: ${match.sessionId}`);
   logger.info(`Started: ${match.firstTimestamp}`);
   logger.info(`Ended:   ${match.lastTimestamp}`);
@@ -8164,9 +8943,13 @@ function printSessionDetail(match) {
   }
   const hitRate = computeCacheHitRate(match.cacheReadTokens, match.tokens.inputTokens);
   if (hitRate != null) {
+    const savings = computeCacheSavings(match.cacheReadTokens, match.model, pricingData);
     logger.info("");
     logger.info("Cache Performance:");
     logger.info(`  Cache hit rate:        ${formatPercent(hitRate)}`);
+    if (savings != null) {
+      logger.info(`  Estimated savings:     ${formatMicroUSD(savings)}`);
+    }
   }
   logger.info("");
   logger.info(`Cost: ${formatMicroUSD(match.costMicroUSD)}`);
@@ -8175,8 +8958,11 @@ 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-TZQUURSP.js");
+    const { records, pricingData } = await loadAndPriceRecords(
+      cwd,
+      globalOpts.includeClaudeSessions
+    );
+    const { aggregateBySession } = await import("./dist-WCSJHQPK.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -8186,21 +8972,23 @@ function registerSessionCommand(usage) {
     }
     if (globalOpts.json) {
       const hitRate = computeCacheHitRate(match.cacheReadTokens, match.tokens.inputTokens);
+      const savings = computeCacheSavings(match.cacheReadTokens, match.model, pricingData);
       const enriched = {
         ...match,
-        ...hitRate != null ? { cacheHitRate: Math.round(hitRate * 1e3) / 1e3 } : {}
+        ...hitRate != null ? { cacheHitRate: Math.round(hitRate * 1e3) / 1e3 } : {},
+        ...savings != null ? { cacheSavingsMicroUSD: savings } : {}
       };
       console.log(JSON.stringify(enriched, null, 2));
       return;
     }
-    printSessionDetail(match);
+    printSessionDetail(match, pricingData);
   });
 }
 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);
+    const { records } = await loadAndPriceRecords(cwd, globalOpts.includeClaudeSessions);
     if (records.length === 0) {
       if (globalOpts.json) {
         console.log(JSON.stringify({ error: "No usage data found" }));
@@ -8209,7 +8997,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-TZQUURSP.js");
+    const { aggregateBySession } = await import("./dist-WCSJHQPK.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -8235,7 +9023,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command78("usage").description("Token usage and cost tracking");
+  const usage = new Command81("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -8248,15 +9036,17 @@ function createUsageCommand() {
 }
 
 // src/commands/validate.ts
-import { Command as Command79 } from "commander";
-import * as path59 from "path";
+init_dist();
+init_dist();
+import { Command as Command82 } from "commander";
+import * as path62 from "path";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path59.dirname(path59.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path62.dirname(path62.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -8266,7 +9056,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path59.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path62.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -8302,6 +9092,26 @@ async function runValidate(options) {
     });
   }
   result.checks.fileStructure = true;
+  if (options.agentConfigs) {
+    const agentCfg = await validateAgentConfigs(cwd, {
+      strict: options.strict === true,
+      ...options.agnixBin !== void 0 && { agnixBin: options.agnixBin }
+    });
+    result.agentConfigs = agentCfg;
+    result.checks.agentConfigs = agentCfg.valid;
+    if (!agentCfg.valid) result.valid = false;
+    for (const finding of agentCfg.issues) {
+      result.issues.push({
+        check: "agentConfigs",
+        file: finding.file,
+        ...finding.line !== void 0 && { line: finding.line },
+        ruleId: finding.ruleId,
+        severity: finding.severity,
+        message: finding.message,
+        ...finding.suggestion !== void 0 && { suggestion: finding.suggestion }
+      });
+    }
+  }
   return Ok(result);
 }
 function resolveValidateMode(globalOpts) {
@@ -8311,11 +9121,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-M4NP2UF5.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-ZOWFA3DB.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path59.join(cwd, "docs", "specs"),
-    plansDir: path59.join(cwd, "docs", "plans"),
+    specsDir: path62.join(cwd, "docs", "specs"),
+    plansDir: path62.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -8327,37 +9137,59 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command79("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const mode = resolveValidateMode(globalOpts);
-    const formatter = new OutputFormatter(mode);
-    const result = await runValidate({
-      configPath: globalOpts.config,
-      json: globalOpts.json,
-      verbose: globalOpts.verbose,
-      quiet: globalOpts.quiet
-    });
-    if (!result.ok) {
-      if (mode === OutputMode.JSON) console.log(JSON.stringify({ error: result.error.message }));
-      else logger.error(result.error.message);
-      process.exit(result.error.exitCode);
-    }
-    if (opts.crossCheck) await printCrossCheckWarnings(mode);
-    const output = formatter.formatValidation({
-      valid: result.value.valid,
-      issues: result.value.issues
-    });
-    if (output) console.log(output);
-    process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
-  });
+  const command = new Command82("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+    "--agent-configs",
+    "Validate agent configs (CLAUDE.md, hooks, skills) via agnix or built-in fallback rules"
+  ).option("--strict", "Treat warnings as errors (applies to --agent-configs)").option("--agnix-bin <path>", "Override the agnix binary path discovered on PATH").action(async (opts, cmd) => runValidateAction(opts, cmd.optsWithGlobals()));
   return command;
 }
+async function runValidateAction(opts, globalOpts) {
+  const mode = resolveValidateMode(globalOpts);
+  const formatter = new OutputFormatter(mode);
+  const result = await runValidate({
+    ...typeof globalOpts.config === "string" && { configPath: globalOpts.config },
+    json: globalOpts.json === true,
+    verbose: globalOpts.verbose === true,
+    quiet: globalOpts.quiet === true,
+    agentConfigs: opts.agentConfigs === true,
+    strict: opts.strict === true,
+    ...typeof opts.agnixBin === "string" && { agnixBin: opts.agnixBin }
+  });
+  if (!result.ok) {
+    if (mode === OutputMode.JSON) console.log(JSON.stringify({ error: result.error.message }));
+    else logger.error(result.error.message);
+    process.exit(result.error.exitCode);
+  }
+  if (opts.crossCheck) await printCrossCheckWarnings(mode);
+  emitValidateOutput(result.value, mode, formatter);
+  process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
+}
+function emitValidateOutput(value, mode, formatter) {
+  if (mode === OutputMode.JSON) {
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  const output = formatter.formatValidation({ valid: value.valid, issues: value.issues });
+  if (output) console.log(output);
+  if (value.agentConfigs) printAgentConfigSummary(value.agentConfigs, mode);
+}
+function printAgentConfigSummary(cfg, mode) {
+  if (mode === OutputMode.QUIET) return;
+  const engineLabel = cfg.engine === "agnix" ? "agnix" : "built-in fallback rules";
+  const note = cfg.fellBackBecause ? ` (${cfg.fellBackBecause})` : "";
+  console.log(`
+Agent configs checked via ${engineLabel}${note}`);
+  if (cfg.engine === "fallback" && cfg.fellBackBecause === "binary-not-found") {
+    console.log("  Install agnix for 385+ rule coverage: https://github.com/agent-sh/agnix");
+  }
+}
 
 // src/commands/_registry.ts
 var commandCreators = [
   createAddCommand,
   createAdoptionCommand,
   createAgentCommand,
+  createAuditProtectedCommand,
   createBlueprintCommand,
   createCheckArchCommand,
   createCheckDepsCommand,
@@ -8390,6 +9222,7 @@ var commandCreators = [
   createPerfCommand,
   createPersonaCommand,
   createPredictCommand,
+  createPublishAnalysesCommand,
   createQueryCommand,
   createRecommendCommand,
   createScanCommand,
@@ -8400,6 +9233,7 @@ var commandCreators = [
   createSkillCommand,
   createSnapshotCommand,
   createStateCommand,
+  createSyncAnalysesCommand,
   createTaintCommand,
   createTelemetryCommand,
   createTraceabilityCommand,
@@ -8412,7 +9246,7 @@ var commandCreators = [
 
 // src/index.ts
 function createProgram() {
-  const program = new Command80();
+  const program = new Command83();
   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");
   for (const creator of commandCreators) {
     program.addCommand(creator());
@@ -8424,7 +9258,6 @@ export {
   runCheckArch,
   runGraphStatus,
   runGraphExport,
-  runScan,
   runQuery,
   runIngest,
   runImpactPreview,