@harness-engineering/cli 1.6.0 → 1.6.1

package/dist/{chunk-VS4OTOKZ.js → chunk-O6NEKDYP.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-ACMDUQJG.js";
 
 // src/index.ts
-import { Command as Command39 } from "commander";
+import { Command as Command43 } from "commander";
 import { VERSION } from "@harness-engineering/core";
 
 // src/commands/validate.ts
@@ -400,10 +400,404 @@ function createCheckDepsCommand() {
   return command;
 }
 
-// src/commands/check-docs.ts
+// src/commands/check-perf.ts
 import { Command as Command3 } from "commander";
 import * as path4 from "path";
-import { Ok as Ok4, Err as Err2 } from "@harness-engineering/core";
+import { Ok as Ok4, EntropyAnalyzer } from "@harness-engineering/core";
+async function runCheckPerf(cwd, options) {
+  const runAll = !options.structural && !options.size && !options.coupling;
+  const analyzer = new EntropyAnalyzer({
+    rootDir: path4.resolve(cwd),
+    analyze: {
+      complexity: runAll || !!options.structural,
+      coupling: runAll || !!options.coupling,
+      sizeBudget: runAll || !!options.size
+    }
+  });
+  const analysisResult = await analyzer.analyze();
+  if (!analysisResult.ok) {
+    return Ok4({
+      valid: false,
+      violations: [
+        {
+          tier: 1,
+          severity: "error",
+          metric: "analysis-error",
+          file: "",
+          value: 0,
+          threshold: 0,
+          message: `Analysis failed: ${analysisResult.error.message}`
+        }
+      ],
+      stats: { filesAnalyzed: 0, violationCount: 1, errorCount: 1, warningCount: 0, infoCount: 0 }
+    });
+  }
+  const report = analysisResult.value;
+  const violations = [];
+  if (report.complexity) {
+    for (const v of report.complexity.violations) {
+      violations.push({
+        tier: v.tier,
+        severity: v.severity,
+        metric: v.metric,
+        file: v.file,
+        value: v.value,
+        threshold: v.threshold,
+        message: v.message || `[Tier ${v.tier}] ${v.metric}: ${v.function} (${v.value} > ${v.threshold})`
+      });
+    }
+  }
+  if (report.coupling) {
+    for (const v of report.coupling.violations) {
+      violations.push({
+        tier: v.tier,
+        severity: v.severity,
+        metric: v.metric,
+        file: v.file,
+        value: v.value,
+        threshold: v.threshold,
+        message: v.message || `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`
+      });
+    }
+  }
+  if (report.sizeBudget) {
+    for (const v of report.sizeBudget.violations) {
+      violations.push({
+        tier: v.tier,
+        severity: v.severity,
+        metric: "sizeBudget",
+        file: v.package,
+        value: v.currentSize,
+        threshold: v.budgetSize,
+        message: `[Tier ${v.tier}] Size: ${v.package} (${v.currentSize}B > ${v.budgetSize}B)`
+      });
+    }
+  }
+  const hasErrors = violations.some((v) => v.severity === "error");
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return Ok4({
+    valid: !hasErrors,
+    violations,
+    stats: {
+      filesAnalyzed: report.complexity?.stats.filesAnalyzed ?? 0,
+      violationCount: violations.length,
+      errorCount,
+      warningCount,
+      infoCount
+    }
+  });
+}
+function createCheckPerfCommand() {
+  const command = new Command3("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 globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckPerf(process.cwd(), {
+      structural: opts.structural,
+      coupling: opts.coupling,
+      size: opts.size
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(ExitCode.ERROR);
+    }
+    const issues = result.value.violations.map((v) => ({
+      file: v.file,
+      message: v.message
+    }));
+    const output = formatter.formatValidation({
+      valid: result.value.valid,
+      issues
+    });
+    if (output) {
+      console.log(output);
+    }
+    process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
+  });
+  return command;
+}
+
+// src/commands/check-security.ts
+import { Command as Command4 } from "commander";
+import * as path5 from "path";
+import { execSync } from "child_process";
+import { Ok as Ok5, SecurityScanner, parseSecurityConfig } from "@harness-engineering/core";
+var SEVERITY_RANK = {
+  error: 3,
+  warning: 2,
+  info: 1
+};
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync("git diff --name-only HEAD~1", {
+      cwd,
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path5.resolve(cwd, f));
+  } catch {
+    return [];
+  }
+}
+async function runCheckSecurity(cwd, options) {
+  const projectRoot = path5.resolve(cwd);
+  let configData = {};
+  try {
+    const fs22 = await import("fs");
+    const configPath = path5.join(projectRoot, "harness.config.json");
+    if (fs22.existsSync(configPath)) {
+      const raw = fs22.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      configData = parsed.security ?? {};
+    }
+  } catch {
+  }
+  const securityConfig = parseSecurityConfig(configData);
+  const scanner = new SecurityScanner(securityConfig);
+  scanner.configureForProject(projectRoot);
+  let filesToScan;
+  if (options.changedOnly) {
+    filesToScan = getChangedFiles(projectRoot);
+  } else {
+    const { glob: glob2 } = await import("glob");
+    const pattern = "**/*.{ts,tsx,js,jsx,go,py,java,rb}";
+    const ignore = securityConfig.exclude ?? [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ];
+    filesToScan = await glob2(pattern, { cwd: projectRoot, absolute: true, ignore });
+  }
+  const result = await scanner.scanFiles(filesToScan);
+  const threshold = options.severity ?? "warning";
+  const thresholdRank = SEVERITY_RANK[threshold];
+  const filtered = result.findings.filter((f) => SEVERITY_RANK[f.severity] >= thresholdRank);
+  const hasErrors = filtered.some((f) => f.severity === "error");
+  return Ok5({
+    valid: !hasErrors,
+    findings: filtered,
+    stats: {
+      filesScanned: result.scannedFiles,
+      rulesApplied: result.rulesApplied,
+      errorCount: filtered.filter((f) => f.severity === "error").length,
+      warningCount: filtered.filter((f) => f.severity === "warning").length,
+      infoCount: filtered.filter((f) => f.severity === "info").length
+    }
+  });
+}
+function createCheckSecurityCommand() {
+  const command = new Command4("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`);
+      process.exit(ExitCode.ERROR);
+    }
+  }).option("--changed-only", "Only scan git-changed files").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckSecurity(process.cwd(), {
+      severity: opts.severity,
+      changedOnly: opts.changedOnly
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(ExitCode.ERROR);
+    }
+    const issues = result.value.findings.map((f) => ({
+      file: `${f.file}:${f.line}`,
+      message: `[${f.ruleId}] ${f.severity.toUpperCase()} ${f.message}`
+    }));
+    const output = formatter.formatValidation({
+      valid: result.value.valid,
+      issues
+    });
+    if (output) {
+      console.log(output);
+    }
+    process.exit(result.value.valid ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
+  });
+  return command;
+}
+
+// src/commands/perf.ts
+import { Command as Command5 } from "commander";
+import * as path6 from "path";
+import { BaselineManager, CriticalPathResolver } from "@harness-engineering/core";
+function createPerfCommand() {
+  const perf = new Command5("perf").description("Performance benchmark and baseline management");
+  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("@harness-engineering/core");
+    const runner = new BenchmarkRunner();
+    const benchFiles = runner.discover(cwd, glob2);
+    if (benchFiles.length === 0) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ benchFiles: [], message: "No .bench.ts files found" }));
+      } else {
+        logger.info("No .bench.ts files found. Create *.bench.ts files to add benchmarks.");
+      }
+      return;
+    }
+    if (globalOpts.json) {
+      logger.info(`Found ${benchFiles.length} benchmark file(s). Running...`);
+    } else {
+      logger.info(`Found ${benchFiles.length} benchmark file(s):`);
+      for (const f of benchFiles) {
+        logger.info(`  ${f}`);
+      }
+      logger.info("Running benchmarks...");
+    }
+    const result = await runner.run(glob2 ? { cwd, glob: glob2 } : { cwd });
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ results: result.results, success: result.success }));
+    } else {
+      if (result.success && result.results.length > 0) {
+        logger.info(`
+Results (${result.results.length} benchmarks):`);
+        for (const r of result.results) {
+          logger.info(
+            `  ${r.file}::${r.name}: ${r.opsPerSec} ops/s (mean: ${r.meanMs.toFixed(2)}ms)`
+          );
+        }
+        logger.info("\nTo save as baselines: harness perf baselines update");
+      } else {
+        logger.info("Benchmark run completed. Check output above for details.");
+        if (result.rawOutput) {
+          console.log(result.rawOutput);
+        }
+      }
+    }
+  });
+  const baselines = perf.command("baselines").description("Manage performance baselines");
+  baselines.command("show").description("Display current baselines").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const manager = new BaselineManager(cwd);
+    const data = manager.load();
+    if (!data) {
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ baselines: null, message: "No baselines file found" }));
+      } else {
+        logger.info("No baselines file found at .harness/perf/baselines.json");
+      }
+      return;
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      logger.info(`Baselines (updated: ${data.updatedAt}, from: ${data.updatedFrom})`);
+      for (const [name, baseline] of Object.entries(data.benchmarks)) {
+        logger.info(
+          `  ${name}: ${baseline.opsPerSec} ops/s (mean: ${baseline.meanMs}ms, p99: ${baseline.p99Ms}ms)`
+        );
+      }
+    }
+  });
+  baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const { BenchmarkRunner } = await import("@harness-engineering/core");
+    const runner = new BenchmarkRunner();
+    const manager = new BaselineManager(cwd);
+    logger.info("Running benchmarks to update baselines...");
+    const benchResult = await runner.run({ cwd });
+    if (!benchResult.success || benchResult.results.length === 0) {
+      logger.error(
+        "No benchmark results to save. Run `harness perf bench` first to verify benchmarks work."
+      );
+      return;
+    }
+    let commitHash = "unknown";
+    try {
+      const { execSync: execSync5 } = await import("child_process");
+      commitHash = execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
+    } catch {
+    }
+    manager.save(benchResult.results, commitHash);
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ updated: benchResult.results.length, commitHash }));
+    } else {
+      logger.info(`Updated ${benchResult.results.length} baseline(s) from commit ${commitHash}`);
+      logger.info("Baselines saved to .harness/perf/baselines.json");
+    }
+  });
+  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: EntropyAnalyzer3 } = await import("@harness-engineering/core");
+    const analyzer = new EntropyAnalyzer3({
+      rootDir: path6.resolve(cwd),
+      analyze: { complexity: true, coupling: true }
+    });
+    const result = await analyzer.analyze();
+    if (!result.ok) {
+      logger.error(result.error.message);
+      return;
+    }
+    const report = result.value;
+    if (globalOpts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            complexity: report.complexity,
+            coupling: report.coupling,
+            sizeBudget: report.sizeBudget
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      logger.info("=== Performance Report ===");
+      if (report.complexity) {
+        logger.info(
+          `Complexity: ${report.complexity.stats.violationCount} violations (${report.complexity.stats.errorCount} errors, ${report.complexity.stats.warningCount} warnings)`
+        );
+      }
+      if (report.coupling) {
+        logger.info(
+          `Coupling: ${report.coupling.stats.violationCount} violations (${report.coupling.stats.warningCount} warnings)`
+        );
+      }
+    }
+  });
+  perf.command("critical-paths").description("Show resolved critical path set (annotations + graph inference)").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const resolver = new CriticalPathResolver(cwd);
+    const result = await resolver.resolve();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      logger.info(
+        `Critical paths: ${result.stats.total} (${result.stats.annotated} annotated, ${result.stats.graphInferred} graph-inferred)`
+      );
+      for (const entry of result.entries) {
+        logger.info(
+          `  ${entry.file}::${entry.function} [${entry.source}]${entry.fanIn ? ` (fan-in: ${entry.fanIn})` : ""}`
+        );
+      }
+    }
+  });
+  return perf;
+}
+
+// src/commands/check-docs.ts
+import { Command as Command6 } from "commander";
+import * as path7 from "path";
+import { Ok as Ok6, Err as Err2 } from "@harness-engineering/core";
 import { checkDocCoverage, validateKnowledgeMap as validateKnowledgeMap2 } from "@harness-engineering/core";
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
@@ -413,8 +807,8 @@ async function runCheckDocs(options) {
     return configResult;
   }
   const config = configResult.value;
-  const docsDir = path4.resolve(cwd, config.docsDir);
-  const sourceDir = path4.resolve(cwd, config.rootDir);
+  const docsDir = path7.resolve(cwd, config.docsDir);
+  const sourceDir = path7.resolve(cwd, config.rootDir);
   const coverageResult = await checkDocCoverage("project", {
     docsDir,
     sourceDir,
@@ -443,10 +837,10 @@ async function runCheckDocs(options) {
     undocumented: coverageResult.value.undocumented,
     brokenLinks
   };
-  return Ok4(result);
+  return Ok6(result);
 }
 function createCheckDocsCommand() {
-  const command = new Command3("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").action(async (opts, cmd) => {
+  const command = new Command6("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -498,17 +892,17 @@ function createCheckDocsCommand() {
 }
 
 // src/commands/init.ts
-import { Command as Command5 } from "commander";
+import { Command as Command8 } from "commander";
 import chalk3 from "chalk";
 import * as fs5 from "fs";
-import * as path8 from "path";
-import { Ok as Ok6, Err as Err4 } from "@harness-engineering/core";
+import * as path11 from "path";
+import { Ok as Ok8, Err as Err4 } from "@harness-engineering/core";
 
 // src/templates/engine.ts
 import * as fs2 from "fs";
-import * as path5 from "path";
+import * as path8 from "path";
 import Handlebars from "handlebars";
-import { Ok as Ok5, Err as Err3 } from "@harness-engineering/core";
+import { Ok as Ok7, Err as Err3 } from "@harness-engineering/core";
 
 // src/templates/schema.ts
 import { z as z2 } from "zod";
@@ -576,13 +970,13 @@ var TemplateEngine = class {
       const templates = [];
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const metaPath = path5.join(this.templatesDir, entry.name, "template.json");
+        const metaPath = path8.join(this.templatesDir, entry.name, "template.json");
         if (!fs2.existsSync(metaPath)) continue;
         const raw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
         const parsed = TemplateMetadataSchema.safeParse(raw);
         if (parsed.success) templates.push(parsed.data);
       }
-      return Ok5(templates);
+      return Ok7(templates);
     } catch (error) {
       return Err3(
         new Error(
@@ -594,7 +988,7 @@ var TemplateEngine = class {
   resolveTemplate(level, framework) {
     const levelDir = this.findTemplateDir(level, "level");
     if (!levelDir) return Err3(new Error(`Template not found for level: ${level}`));
-    const metaPath = path5.join(levelDir, "template.json");
+    const metaPath = path8.join(levelDir, "template.json");
     const metaRaw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
     const metaResult = TemplateMetadataSchema.safeParse(metaRaw);
     if (!metaResult.success)
@@ -602,7 +996,7 @@ var TemplateEngine = class {
     const metadata = metaResult.data;
     let files = [];
     if (metadata.extends) {
-      const baseDir = path5.join(this.templatesDir, metadata.extends);
+      const baseDir = path8.join(this.templatesDir, metadata.extends);
       if (fs2.existsSync(baseDir)) files = this.collectFiles(baseDir, metadata.extends);
     }
     const levelFiles = this.collectFiles(levelDir, level);
@@ -611,7 +1005,7 @@ var TemplateEngine = class {
     if (framework) {
       const frameworkDir = this.findTemplateDir(framework, "framework");
       if (!frameworkDir) return Err3(new Error(`Framework template not found: ${framework}`));
-      const fMetaPath = path5.join(frameworkDir, "template.json");
+      const fMetaPath = path8.join(frameworkDir, "template.json");
       const fMetaRaw = JSON.parse(fs2.readFileSync(fMetaPath, "utf-8"));
       const fMetaResult = TemplateMetadataSchema.safeParse(fMetaRaw);
       if (fMetaResult.success) overlayMetadata = fMetaResult.data;
@@ -621,7 +1015,7 @@ var TemplateEngine = class {
     files = files.filter((f) => f.relativePath !== "template.json");
     const resolved = { metadata, files };
     if (overlayMetadata !== void 0) resolved.overlayMetadata = overlayMetadata;
-    return Ok5(resolved);
+    return Ok7(resolved);
   }
   render(template, context) {
     const rendered = [];
@@ -673,20 +1067,20 @@ var TemplateEngine = class {
       const msg = error instanceof Error ? error.message : String(error);
       return Err3(new Error(`JSON merge failed: ${msg}`));
     }
-    return Ok5({ files: rendered });
+    return Ok7({ files: rendered });
   }
   write(files, targetDir, options) {
     try {
       const written = [];
       for (const file of files.files) {
-        const targetPath = path5.join(targetDir, file.relativePath);
-        const dir = path5.dirname(targetPath);
+        const targetPath = path8.join(targetDir, file.relativePath);
+        const dir = path8.dirname(targetPath);
         if (!options.overwrite && fs2.existsSync(targetPath)) continue;
         fs2.mkdirSync(dir, { recursive: true });
         fs2.writeFileSync(targetPath, file.content);
         written.push(file.relativePath);
       }
-      return Ok5(written);
+      return Ok7(written);
     } catch (error) {
       return Err3(
         new Error(
@@ -699,16 +1093,16 @@ var TemplateEngine = class {
     const entries = fs2.readdirSync(this.templatesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path5.join(this.templatesDir, entry.name, "template.json");
+      const metaPath = path8.join(this.templatesDir, entry.name, "template.json");
       if (!fs2.existsSync(metaPath)) continue;
       const raw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
       const parsed = TemplateMetadataSchema.safeParse(raw);
       if (!parsed.success) continue;
       if (type === "level" && parsed.data.level === name)
-        return path5.join(this.templatesDir, entry.name);
+        return path8.join(this.templatesDir, entry.name);
       if (type === "framework" && parsed.data.framework === name)
-        return path5.join(this.templatesDir, entry.name);
-      if (parsed.data.name === name) return path5.join(this.templatesDir, entry.name);
+        return path8.join(this.templatesDir, entry.name);
+      if (parsed.data.name === name) return path8.join(this.templatesDir, entry.name);
     }
     return null;
   }
@@ -717,12 +1111,12 @@ var TemplateEngine = class {
     const walk = (currentDir) => {
       const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path5.join(currentDir, entry.name);
+        const fullPath = path8.join(currentDir, entry.name);
         if (entry.isDirectory()) {
           walk(fullPath);
         } else {
           files.push({
-            relativePath: path5.relative(dir, fullPath),
+            relativePath: path8.relative(dir, fullPath),
             absolutePath: fullPath,
             isHandlebars: entry.name.endsWith(".hbs"),
             sourceTemplate: sourceName
@@ -754,51 +1148,51 @@ var TemplateEngine = class {
 
 // src/utils/paths.ts
 import * as fs3 from "fs";
-import * as path6 from "path";
+import * as path9 from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path6.dirname(__filename);
+var __dirname = path9.dirname(__filename);
 function findUpDir(targetName, marker, maxLevels = 8) {
   let dir = __dirname;
   for (let i = 0; i < maxLevels; i++) {
-    const candidate = path6.join(dir, targetName);
+    const candidate = path9.join(dir, targetName);
     if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
-      if (fs3.existsSync(path6.join(candidate, marker))) {
+      if (fs3.existsSync(path9.join(candidate, marker))) {
         return candidate;
       }
     }
-    dir = path6.dirname(dir);
+    dir = path9.dirname(dir);
   }
   return null;
 }
 function resolveTemplatesDir() {
-  return findUpDir("templates", "base") ?? path6.join(__dirname, "templates");
+  return findUpDir("templates", "base") ?? path9.join(__dirname, "templates");
 }
 function resolvePersonasDir() {
   const agentsDir = findUpDir("agents", "personas");
   if (agentsDir) {
-    return path6.join(agentsDir, "personas");
+    return path9.join(agentsDir, "personas");
   }
-  return path6.join(__dirname, "agents", "personas");
+  return path9.join(__dirname, "agents", "personas");
 }
 function resolveSkillsDir() {
   const agentsDir = findUpDir("agents", "skills");
   if (agentsDir) {
-    return path6.join(agentsDir, "skills", "claude-code");
+    return path9.join(agentsDir, "skills", "claude-code");
   }
-  return path6.join(__dirname, "agents", "skills", "claude-code");
+  return path9.join(__dirname, "agents", "skills", "claude-code");
 }
 function resolveProjectSkillsDir(cwd) {
   let dir = cwd ?? process.cwd();
   for (let i = 0; i < 8; i++) {
-    const candidate = path6.join(dir, "agents", "skills", "claude-code");
+    const candidate = path9.join(dir, "agents", "skills", "claude-code");
     if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
-      const agentsDir = path6.join(dir, "agents");
-      if (fs3.existsSync(path6.join(agentsDir, "skills"))) {
+      const agentsDir = path9.join(dir, "agents");
+      if (fs3.existsSync(path9.join(agentsDir, "skills"))) {
         return candidate;
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path9.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -807,15 +1201,15 @@ function resolveProjectSkillsDir(cwd) {
 function resolveGlobalSkillsDir() {
   const agentsDir = findUpDir("agents", "skills");
   if (agentsDir) {
-    return path6.join(agentsDir, "skills", "claude-code");
+    return path9.join(agentsDir, "skills", "claude-code");
   }
-  return path6.join(__dirname, "agents", "skills", "claude-code");
+  return path9.join(__dirname, "agents", "skills", "claude-code");
 }
 
 // src/commands/setup-mcp.ts
-import { Command as Command4 } from "commander";
+import { Command as Command7 } from "commander";
 import * as fs4 from "fs";
-import * as path7 from "path";
+import * as path10 from "path";
 import * as os from "os";
 import chalk2 from "chalk";
 var HARNESS_MCP_ENTRY = {
@@ -832,7 +1226,7 @@ function readJsonFile(filePath) {
   }
 }
 function writeJsonFile(filePath, data) {
-  const dir = path7.dirname(filePath);
+  const dir = path10.dirname(filePath);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
@@ -851,7 +1245,7 @@ function configureMcpServer(configPath) {
   return true;
 }
 function addGeminiTrustedFolder(cwd) {
-  const trustedPath = path7.join(os.homedir(), ".gemini", "trustedFolders.json");
+  const trustedPath = path10.join(os.homedir(), ".gemini", "trustedFolders.json");
   const folders = readJsonFile(trustedPath) ?? {};
   if (folders[cwd] === "TRUST_FOLDER") {
     return false;
@@ -865,7 +1259,7 @@ function setupMcp(cwd, client) {
   const skipped = [];
   let trustedFolder = false;
   if (client === "all" || client === "claude") {
-    const configPath = path7.join(cwd, ".mcp.json");
+    const configPath = path10.join(cwd, ".mcp.json");
     if (configureMcpServer(configPath)) {
       configured.push("Claude Code");
     } else {
@@ -873,7 +1267,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "gemini") {
-    const configPath = path7.join(cwd, ".gemini", "settings.json");
+    const configPath = path10.join(cwd, ".gemini", "settings.json");
     if (configureMcpServer(configPath)) {
       configured.push("Gemini CLI");
     } else {
@@ -884,7 +1278,7 @@ function setupMcp(cwd, client) {
   return { configured, skipped, trustedFolder };
 }
 function createSetupMcpCommand() {
-  return new Command4("setup-mcp").description("Configure MCP server for AI agent integration").option("--client <client>", "Client to configure (claude, gemini, all)", "all").action(async (opts, cmd) => {
+  return new Command7("setup-mcp").description("Configure MCP server for AI agent integration").option("--client <client>", "Client to configure (claude, gemini, all)", "all").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
     const { configured, skipped, trustedFolder } = setupMcp(cwd, opts.client);
@@ -910,8 +1304,12 @@ function createSetupMcpCommand() {
       }
       console.log("");
       console.log(chalk2.bold("The harness MCP server provides:"));
-      console.log("  - 15 tools for validation, entropy detection, and skill execution");
-      console.log("  - 4 resources for project context, skills, rules, and learnings");
+      console.log(
+        "  - 31 tools for validation, entropy detection, skill execution, graph querying, and more"
+      );
+      console.log(
+        "  - 8 resources for project context, skills, rules, learnings, state, and graph data"
+      );
       console.log("");
       console.log(`Run ${chalk2.cyan("harness skill list")} to see available skills.`);
       console.log("");
@@ -923,10 +1321,10 @@ function createSetupMcpCommand() {
 // src/commands/init.ts
 async function runInit(options) {
   const cwd = options.cwd ?? process.cwd();
-  const name = options.name ?? path8.basename(cwd);
+  const name = options.name ?? path11.basename(cwd);
   const level = options.level ?? "basic";
   const force = options.force ?? false;
-  const configPath = path8.join(cwd, "harness.config.json");
+  const configPath = path11.join(cwd, "harness.config.json");
   if (!force && fs5.existsSync(configPath)) {
     return Err4(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
@@ -950,10 +1348,10 @@ async function runInit(options) {
   if (!writeResult.ok) {
     return Err4(new CLIError(writeResult.error.message, ExitCode.ERROR));
   }
-  return Ok6({ filesCreated: writeResult.value });
+  return Ok8({ filesCreated: writeResult.value });
 }
 function createInitCommand() {
-  const command = new Command5("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
+  const command = new Command8("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const result = await runInit({
       name: opts.name,
@@ -995,9 +1393,9 @@ function createInitCommand() {
 }
 
 // src/commands/cleanup.ts
-import { Command as Command6 } from "commander";
-import * as path9 from "path";
-import { Ok as Ok7, Err as Err5, EntropyAnalyzer } from "@harness-engineering/core";
+import { Command as Command9 } from "commander";
+import * as path12 from "path";
+import { Ok as Ok9, Err as Err5, EntropyAnalyzer as EntropyAnalyzer2 } from "@harness-engineering/core";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
@@ -1012,11 +1410,11 @@ async function runCleanup(options) {
     patternViolations: [],
     totalIssues: 0
   };
-  const rootDir = path9.resolve(cwd, config.rootDir);
-  const docsDir = path9.resolve(cwd, config.docsDir);
+  const rootDir = path12.resolve(cwd, config.rootDir);
+  const docsDir = path12.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path9.join(rootDir, "src/index.ts")],
+    entryPoints: [path12.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: type === "all" || type === "drift",
@@ -1025,7 +1423,7 @@ async function runCleanup(options) {
     },
     exclude: config.entropy?.excludePatterns ?? ["**/node_modules/**", "**/*.test.ts"]
   };
-  const analyzer = new EntropyAnalyzer(entropyConfig);
+  const analyzer = new EntropyAnalyzer2(entropyConfig);
   const analysisResult = await analyzer.analyze();
   if (!analysisResult.ok) {
     return Err5(
@@ -1053,10 +1451,10 @@ async function runCleanup(options) {
     }));
   }
   result.totalIssues = result.driftIssues.length + result.deadCode.length + result.patternViolations.length;
-  return Ok7(result);
+  return Ok9(result);
 }
 function createCleanupCommand() {
-  const command = new Command6("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 Command9("cleanup").description("Detect entropy issues (doc drift, dead code, patterns)").option("-t, --type <type>", "Issue type: drift, dead-code, patterns, all", "all").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -1116,10 +1514,10 @@ function createCleanupCommand() {
 }
 
 // src/commands/fix-drift.ts
-import { Command as Command7 } from "commander";
-import * as path10 from "path";
+import { Command as Command10 } from "commander";
+import * as path13 from "path";
 import {
-  Ok as Ok8,
+  Ok as Ok10,
   Err as Err6,
   buildSnapshot,
   detectDocDrift,
@@ -1136,11 +1534,11 @@ async function runFixDrift(options) {
     return Err6(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path10.resolve(cwd, config.rootDir);
-  const docsDir = path10.resolve(cwd, config.docsDir);
+  const rootDir = path13.resolve(cwd, config.rootDir);
+  const docsDir = path13.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path10.join(rootDir, "src/index.ts")],
+    entryPoints: [path13.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: true,
@@ -1224,10 +1622,10 @@ async function runFixDrift(options) {
     fixes: appliedFixes,
     suggestions
   };
-  return Ok8(result);
+  return Ok10(result);
 }
 function createFixDriftCommand() {
-  const command = new Command7("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 Command10("fix-drift").description("Auto-fix entropy issues (doc drift, dead code)").option("--no-dry-run", "Actually apply fixes (default is dry-run mode)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -1287,20 +1685,20 @@ function createFixDriftCommand() {
 }
 
 // src/commands/agent/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/commands/agent/run.ts
-import { Command as Command8 } from "commander";
-import * as path14 from "path";
+import { Command as Command11 } from "commander";
+import * as path17 from "path";
 import * as childProcess from "child_process";
-import { Ok as Ok10, Err as Err8 } from "@harness-engineering/core";
+import { Ok as Ok12, Err as Err8 } from "@harness-engineering/core";
 import { requestPeerReview } from "@harness-engineering/core";
 
 // src/persona/loader.ts
 import * as fs6 from "fs";
-import * as path11 from "path";
+import * as path14 from "path";
 import YAML from "yaml";
-import { Ok as Ok9, Err as Err7 } from "@harness-engineering/core";
+import { Ok as Ok11, Err as Err7 } from "@harness-engineering/core";
 
 // src/persona/schema.ts
 import { z as z3 } from "zod";
@@ -1394,7 +1792,7 @@ function loadPersona(filePath) {
     if (!result.success) {
       return Err7(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
     }
-    return Ok9(normalizePersona(result.data));
+    return Ok11(normalizePersona(result.data));
   } catch (error) {
     return Err7(
       new Error(`Failed to load persona: ${error instanceof Error ? error.message : String(error)}`)
@@ -1403,17 +1801,17 @@ function loadPersona(filePath) {
 }
 function listPersonas(dir) {
   try {
-    if (!fs6.existsSync(dir)) return Ok9([]);
+    if (!fs6.existsSync(dir)) return Ok11([]);
     const entries = fs6.readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     const personas = [];
     for (const entry of entries) {
-      const filePath = path11.join(dir, entry);
+      const filePath = path14.join(dir, entry);
       const result = loadPersona(filePath);
       if (result.ok) {
         personas.push({ name: result.value.name, description: result.value.description, filePath });
       }
     }
-    return Ok9(personas);
+    return Ok11(personas);
   } catch (error) {
     return Err7(
       new Error(
@@ -1425,9 +1823,9 @@ function listPersonas(dir) {
 
 // src/persona/trigger-detector.ts
 import * as fs7 from "fs";
-import * as path12 from "path";
+import * as path15 from "path";
 function detectTrigger(projectPath) {
-  const handoffPath = path12.join(projectPath, ".harness", "handoff.json");
+  const handoffPath = path15.join(projectPath, ".harness", "handoff.json");
   if (!fs7.existsSync(handoffPath)) {
     return { trigger: "manual" };
   }
@@ -1506,8 +1904,8 @@ async function runPersona(persona, context) {
       const result = await Promise.race([
         context.commandExecutor(step.command),
         new Promise(
-          (resolve18) => setTimeout(
-            () => resolve18({
+          (resolve22) => setTimeout(
+            () => resolve22({
               ok: false,
               error: new Error(TIMEOUT_ERROR_MESSAGE)
             }),
@@ -1562,7 +1960,7 @@ async function runPersona(persona, context) {
       const result = await Promise.race([
         context.skillExecutor(step.skill, skillContext),
         new Promise(
-          (resolve18) => setTimeout(() => resolve18(SKILL_TIMEOUT_RESULT), remainingTime)
+          (resolve22) => setTimeout(() => resolve22(SKILL_TIMEOUT_RESULT), remainingTime)
         )
       ]);
       const durationMs = Date.now() - stepStart;
@@ -1606,7 +2004,7 @@ async function runPersona(persona, context) {
 
 // src/persona/skill-executor.ts
 import * as fs8 from "fs";
-import * as path13 from "path";
+import * as path16 from "path";
 import { parse as parse2 } from "yaml";
 function resolveOutputMode(mode, trigger) {
   if (mode !== "auto") return mode;
@@ -1615,7 +2013,7 @@ function resolveOutputMode(mode, trigger) {
 function buildArtifactPath(projectPath, headSha) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const sha = headSha?.slice(0, 7) ?? "unknown";
-  return path13.join(projectPath, ".harness", "reviews", `${date}-${sha}.md`);
+  return path16.join(projectPath, ".harness", "reviews", `${date}-${sha}.md`);
 }
 function buildArtifactContent(skillName, trigger, headSha) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -1661,7 +2059,7 @@ function buildArtifactContent(skillName, trigger, headSha) {
 async function executeSkill(skillName, context) {
   const startTime = Date.now();
   const skillsDir = resolveSkillsDir();
-  const skillDir = path13.join(skillsDir, skillName);
+  const skillDir = path16.join(skillsDir, skillName);
   if (!fs8.existsSync(skillDir)) {
     return {
       status: "fail",
@@ -1669,7 +2067,7 @@ async function executeSkill(skillName, context) {
       durationMs: Date.now() - startTime
     };
   }
-  const yamlPath = path13.join(skillDir, "skill.yaml");
+  const yamlPath = path16.join(skillDir, "skill.yaml");
   if (!fs8.existsSync(yamlPath)) {
     return {
       status: "fail",
@@ -1687,7 +2085,7 @@ async function executeSkill(skillName, context) {
       durationMs: Date.now() - startTime
     };
   }
-  const skillMdPath = path13.join(skillDir, "SKILL.md");
+  const skillMdPath = path16.join(skillDir, "SKILL.md");
   if (!fs8.existsSync(skillMdPath)) {
     return {
       status: "fail",
@@ -1707,7 +2105,7 @@ Trigger: ${context.trigger}
   if (resolvedMode === "artifact") {
     artifactPath = buildArtifactPath(context.projectPath, context.headSha);
     const artifactContent = buildArtifactContent(skillName, context.trigger, context.headSha);
-    const dir = path13.dirname(artifactPath);
+    const dir = path16.dirname(artifactPath);
     fs8.mkdirSync(dir, { recursive: true });
     fs8.writeFileSync(artifactPath, artifactContent, "utf-8");
   }
@@ -1724,6 +2122,8 @@ var ALLOWED_PERSONA_COMMANDS = /* @__PURE__ */ new Set([
   "validate",
   "check-deps",
   "check-docs",
+  "check-perf",
+  "check-security",
   "cleanup",
   "fix-drift",
   "add"
@@ -1765,7 +2165,7 @@ async function runAgentTask(task, options) {
     return Err8(new CLIError(`Agent task failed: ${reviewResult.error.message}`, ExitCode.ERROR));
   }
   const review = reviewResult.value;
-  return Ok10({
+  return Ok12({
     success: review.approved,
     output: review.approved ? `Agent task '${task}' completed successfully` : `Agent task '${task}' found issues:
 ${review.comments.map((c) => `  - ${c.message}`).join("\n")}`
@@ -1782,11 +2182,11 @@ var VALID_TRIGGERS = /* @__PURE__ */ new Set([
   "auto"
 ]);
 function createRunCommand() {
-  return new Command8("run").description("Run an agent task").argument("[task]", "Task to run (review, doc-review, test-review)").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--persona <name>", "Run a persona by name").option("--trigger <context>", "Trigger context (auto, on_pr, on_commit, manual)", "auto").action(async (task, opts, cmd) => {
+  return new Command11("run").description("Run an agent task").argument("[task]", "Task to run (review, doc-review, test-review)").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--persona <name>", "Run a persona by name").option("--trigger <context>", "Trigger context (auto, on_pr, on_commit, manual)", "auto").action(async (task, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     if (opts.persona) {
       const personasDir = resolvePersonasDir();
-      const filePath = path14.join(personasDir, `${opts.persona}.yaml`);
+      const filePath = path17.join(personasDir, `${opts.persona}.yaml`);
       const personaResult = loadPersona(filePath);
       if (!personaResult.ok) {
         logger.error(personaResult.error.message);
@@ -1801,7 +2201,7 @@ function createRunCommand() {
         }
         try {
           childProcess.execFileSync("npx", ["harness", command], { stdio: "inherit" });
-          return Ok10(null);
+          return Ok12(null);
         } catch (error) {
           return Err8(new Error(error instanceof Error ? error.message : String(error)));
         }
@@ -1843,9 +2243,9 @@ function createRunCommand() {
 }
 
 // src/commands/agent/review.ts
-import { Command as Command9 } from "commander";
-import { execSync } from "child_process";
-import { Ok as Ok11, Err as Err9 } from "@harness-engineering/core";
+import { Command as Command12 } from "commander";
+import { execSync as execSync2 } from "child_process";
+import { Ok as Ok13, Err as Err9 } from "@harness-engineering/core";
 import { createSelfReview, parseDiff } from "@harness-engineering/core";
 async function runAgentReview(options) {
   const configResult = resolveConfig(options.configPath);
@@ -1855,15 +2255,15 @@ async function runAgentReview(options) {
   const config = configResult.value;
   let diff;
   try {
-    diff = execSync("git diff --cached", { encoding: "utf-8" });
+    diff = execSync2("git diff --cached", { encoding: "utf-8" });
     if (!diff) {
-      diff = execSync("git diff", { encoding: "utf-8" });
+      diff = execSync2("git diff", { encoding: "utf-8" });
     }
   } catch {
     return Err9(new CLIError("Failed to get git diff", ExitCode.ERROR));
   }
   if (!diff) {
-    return Ok11({
+    return Ok13({
       passed: true,
       checklist: [{ check: "No changes to review", passed: true }]
     });
@@ -1883,7 +2283,7 @@ async function runAgentReview(options) {
   if (!review.ok) {
     return Err9(new CLIError(review.error.message, ExitCode.ERROR));
   }
-  return Ok11({
+  return Ok13({
     passed: review.value.passed,
     checklist: review.value.items.map((item) => ({
       check: item.check,
@@ -1893,7 +2293,7 @@ async function runAgentReview(options) {
   });
 }
 function createReviewCommand() {
-  return new Command9("review").description("Run self-review on current changes").action(async (_opts, cmd) => {
+  return new Command12("review").description("Run self-review on current changes").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : OutputMode.TEXT;
     const result = await runAgentReview({
@@ -1929,17 +2329,17 @@ function createReviewCommand() {
 
 // src/commands/agent/index.ts
 function createAgentCommand() {
-  const command = new Command10("agent").description("Agent orchestration commands");
+  const command = new Command13("agent").description("Agent orchestration commands");
   command.addCommand(createRunCommand());
   command.addCommand(createReviewCommand());
   return command;
 }
 
 // src/commands/add.ts
-import { Command as Command11 } from "commander";
+import { Command as Command14 } from "commander";
 import * as fs9 from "fs";
-import * as path15 from "path";
-import { Ok as Ok12, Err as Err10 } from "@harness-engineering/core";
+import * as path18 from "path";
+import { Ok as Ok14, Err as Err10 } from "@harness-engineering/core";
 var LAYER_INDEX_TEMPLATE = (name) => `// ${name} layer
 // Add your ${name} exports here
 
@@ -1983,12 +2383,12 @@ async function runAdd(componentType, name, options) {
   try {
     switch (componentType) {
       case "layer": {
-        const layerDir = path15.join(cwd, "src", name);
+        const layerDir = path18.join(cwd, "src", name);
         if (!fs9.existsSync(layerDir)) {
           fs9.mkdirSync(layerDir, { recursive: true });
           created.push(`src/${name}/`);
         }
-        const indexPath = path15.join(layerDir, "index.ts");
+        const indexPath = path18.join(layerDir, "index.ts");
         if (!fs9.existsSync(indexPath)) {
           fs9.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
           created.push(`src/${name}/index.ts`);
@@ -1996,7 +2396,7 @@ async function runAdd(componentType, name, options) {
         break;
       }
       case "module": {
-        const modulePath = path15.join(cwd, "src", `${name}.ts`);
+        const modulePath = path18.join(cwd, "src", `${name}.ts`);
         if (fs9.existsSync(modulePath)) {
           return Err10(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
         }
@@ -2005,11 +2405,11 @@ async function runAdd(componentType, name, options) {
         break;
       }
       case "doc": {
-        const docsDir = path15.join(cwd, "docs");
+        const docsDir = path18.join(cwd, "docs");
         if (!fs9.existsSync(docsDir)) {
           fs9.mkdirSync(docsDir, { recursive: true });
         }
-        const docPath = path15.join(docsDir, `${name}.md`);
+        const docPath = path18.join(docsDir, `${name}.md`);
         if (fs9.existsSync(docPath)) {
           return Err10(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
         }
@@ -2022,18 +2422,18 @@ async function runAdd(componentType, name, options) {
         generateSkillFiles2({
           name,
           description: `${name} skill`,
-          outputDir: path15.join(cwd, "agents", "skills", "claude-code")
+          outputDir: path18.join(cwd, "agents", "skills", "claude-code")
         });
         created.push(`agents/skills/claude-code/${name}/skill.yaml`);
         created.push(`agents/skills/claude-code/${name}/SKILL.md`);
         break;
       }
       case "persona": {
-        const personasDir = path15.join(cwd, "agents", "personas");
+        const personasDir = path18.join(cwd, "agents", "personas");
         if (!fs9.existsSync(personasDir)) {
           fs9.mkdirSync(personasDir, { recursive: true });
         }
-        const personaPath = path15.join(personasDir, `${name}.yaml`);
+        const personaPath = path18.join(personasDir, `${name}.yaml`);
         if (fs9.existsSync(personaPath)) {
           return Err10(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
         }
@@ -2059,7 +2459,7 @@ focus_areas: []
         );
       }
     }
-    return Ok12({ created });
+    return Ok14({ created });
   } catch (error) {
     return Err10(
       new CLIError(
@@ -2070,7 +2470,7 @@ focus_areas: []
   }
 }
 function createAddCommand() {
-  const command = new Command11("add").description("Add a component to the project").argument("<type>", "Component type (layer, module, doc, skill, persona)").argument("<name>", "Component name").action(async (type, name, _opts, cmd) => {
+  const command = new Command14("add").description("Add a component to the project").argument("<type>", "Component type (layer, module, doc, skill, persona)").argument("<name>", "Component name").action(async (type, name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const result = await runAdd(type, name, {
       ...globalOpts.config !== void 0 && { configPath: globalOpts.config }
@@ -2091,13 +2491,13 @@ function createAddCommand() {
 }
 
 // src/commands/linter/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/linter/generate.ts
-import { Command as Command12 } from "commander";
+import { Command as Command15 } from "commander";
 import { generate } from "@harness-engineering/linter-gen";
 function createGenerateCommand() {
-  return new Command12("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 Command15("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}`);
@@ -2159,10 +2559,10 @@ Generated ${result.rulesGenerated.length} rules to ${result.outputDir}`);
 }
 
 // src/commands/linter/validate.ts
-import { Command as Command13 } from "commander";
+import { Command as Command16 } from "commander";
 import { validate } from "@harness-engineering/linter-gen";
 function createValidateCommand2() {
-  return new Command13("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 Command16("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) {
@@ -2181,7 +2581,7 @@ function createValidateCommand2() {
 
 // src/commands/linter/index.ts
 function createLinterCommand() {
-  const linter = new Command14("linter").description(
+  const linter = new Command17("linter").description(
     "Generate and validate ESLint rules from YAML config"
   );
   linter.addCommand(createGenerateCommand());
@@ -2190,12 +2590,12 @@ function createLinterCommand() {
 }
 
 // src/commands/persona/index.ts
-import { Command as Command17 } from "commander";
+import { Command as Command20 } from "commander";
 
 // src/commands/persona/list.ts
-import { Command as Command15 } from "commander";
+import { Command as Command18 } from "commander";
 function createListCommand() {
-  return new Command15("list").description("List available agent personas").action(async (_opts, cmd) => {
+  return new Command18("list").description("List available agent personas").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
     const result = listPersonas(personasDir);
@@ -2224,12 +2624,12 @@ function createListCommand() {
 }
 
 // src/commands/persona/generate.ts
-import { Command as Command16 } from "commander";
+import { Command as Command19 } from "commander";
 import * as fs10 from "fs";
-import * as path16 from "path";
+import * as path19 from "path";
 
 // src/persona/generators/runtime.ts
-import { Ok as Ok13, Err as Err11 } from "@harness-engineering/core";
+import { Ok as Ok15, Err as Err11 } from "@harness-engineering/core";
 
 // src/utils/string.ts
 function toKebabCase(name) {
@@ -2246,7 +2646,7 @@ function generateRuntime(persona) {
       timeout: persona.config.timeout,
       severity: persona.config.severity
     };
-    return Ok13(JSON.stringify(config, null, 2));
+    return Ok15(JSON.stringify(config, null, 2));
   } catch (error) {
     return Err11(
       new Error(
@@ -2257,7 +2657,7 @@ function generateRuntime(persona) {
 }
 
 // src/persona/generators/agents-md.ts
-import { Ok as Ok14, Err as Err12 } from "@harness-engineering/core";
+import { Ok as Ok16, Err as Err12 } from "@harness-engineering/core";
 function formatTrigger(trigger) {
   switch (trigger.event) {
     case "on_pr": {
@@ -2291,7 +2691,7 @@ function generateAgentsMd(persona) {
 
 **When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
 `;
-    return Ok14(fragment);
+    return Ok16(fragment);
   } catch (error) {
     return Err12(
       new Error(
@@ -2303,7 +2703,7 @@ function generateAgentsMd(persona) {
 
 // src/persona/generators/ci-workflow.ts
 import YAML2 from "yaml";
-import { Ok as Ok15, Err as Err13 } from "@harness-engineering/core";
+import { Ok as Ok17, Err as Err13 } from "@harness-engineering/core";
 function buildGitHubTriggers(triggers) {
   const on = {};
   for (const trigger of triggers) {
@@ -2351,7 +2751,7 @@ function generateCIWorkflow(persona, platform) {
         }
       }
     };
-    return Ok15(YAML2.stringify(workflow, { lineWidth: 0 }));
+    return Ok17(YAML2.stringify(workflow, { lineWidth: 0 }));
   } catch (error) {
     return Err13(
       new Error(
@@ -2363,25 +2763,25 @@ function generateCIWorkflow(persona, platform) {
 
 // src/commands/persona/generate.ts
 function createGenerateCommand2() {
-  return new Command16("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 Command19("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
-    const filePath = path16.join(personasDir, `${name}.yaml`);
+    const filePath = path19.join(personasDir, `${name}.yaml`);
     const personaResult = loadPersona(filePath);
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const persona = personaResult.value;
-    const outputDir = path16.resolve(opts.outputDir);
+    const outputDir = path19.resolve(opts.outputDir);
     const slug = toKebabCase(persona.name);
     const only = opts.only;
     const generated = [];
     if (!only || only === "runtime") {
       const result = generateRuntime(persona);
       if (result.ok) {
-        const outPath = path16.join(outputDir, `${slug}.runtime.json`);
-        fs10.mkdirSync(path16.dirname(outPath), { recursive: true });
+        const outPath = path19.join(outputDir, `${slug}.runtime.json`);
+        fs10.mkdirSync(path19.dirname(outPath), { recursive: true });
         fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
@@ -2389,7 +2789,7 @@ function createGenerateCommand2() {
     if (!only || only === "agents-md") {
       const result = generateAgentsMd(persona);
       if (result.ok) {
-        const outPath = path16.join(outputDir, `${slug}.agents.md`);
+        const outPath = path19.join(outputDir, `${slug}.agents.md`);
         fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
@@ -2397,8 +2797,8 @@ function createGenerateCommand2() {
     if (!only || only === "ci") {
       const result = generateCIWorkflow(persona, "github");
       if (result.ok) {
-        const outPath = path16.join(outputDir, ".github", "workflows", `${slug}.yml`);
-        fs10.mkdirSync(path16.dirname(outPath), { recursive: true });
+        const outPath = path19.join(outputDir, ".github", "workflows", `${slug}.yml`);
+        fs10.mkdirSync(path19.dirname(outPath), { recursive: true });
         fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
@@ -2413,22 +2813,22 @@ function createGenerateCommand2() {
 
 // src/commands/persona/index.ts
 function createPersonaCommand() {
-  const command = new Command17("persona").description("Agent persona management commands");
+  const command = new Command20("persona").description("Agent persona management commands");
   command.addCommand(createListCommand());
   command.addCommand(createGenerateCommand2());
   return command;
 }
 
 // src/commands/skill/index.ts
-import { Command as Command22 } from "commander";
+import { Command as Command25 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command18 } from "commander";
+import { Command as Command21 } from "commander";
 import * as fs11 from "fs";
-import * as path17 from "path";
+import * as path20 from "path";
 import { parse as parse3 } from "yaml";
 function createListCommand2() {
-  return new Command18("list").description("List available skills").action(async (_opts, cmd) => {
+  return new Command21("list").description("List available skills").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
     if (!fs11.existsSync(skillsDir)) {
@@ -2439,7 +2839,7 @@ function createListCommand2() {
     const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const skills = [];
     for (const name of entries) {
-      const yamlPath = path17.join(skillsDir, name, "skill.yaml");
+      const yamlPath = path20.join(skillsDir, name, "skill.yaml");
       if (!fs11.existsSync(yamlPath)) continue;
       try {
         const raw = fs11.readFileSync(yamlPath, "utf-8");
@@ -2472,13 +2872,13 @@ function createListCommand2() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command19 } from "commander";
+import { Command as Command22 } from "commander";
 import * as fs12 from "fs";
-import * as path18 from "path";
+import * as path21 from "path";
 import { parse as parse4 } from "yaml";
 
 // src/skill/complexity.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function evaluateSignals(signals) {
   if (signals.fileCount >= 3) return "full";
   if (signals.newDir) return "full";
@@ -2490,17 +2890,17 @@ function evaluateSignals(signals) {
 }
 function detectComplexity(projectPath) {
   try {
-    const base = execSync2("git merge-base HEAD main", {
+    const base = execSync3("git merge-base HEAD main", {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diffFiles = execSync2(`git diff --name-only ${base}`, {
+    const diffFiles = execSync3(`git diff --name-only ${base}`, {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n").filter(Boolean);
-    const diffStat = execSync2(`git diff --stat ${base}`, {
+    const diffStat = execSync3(`git diff --stat ${base}`, {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2562,15 +2962,15 @@ ${options.priorState}`);
 
 // src/commands/skill/run.ts
 function createRunCommand2() {
-  return new Command19("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Complexity: auto, light, full", "auto").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts, _cmd) => {
+  return new Command22("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Complexity: auto, light, full", "auto").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts, _cmd) => {
     const skillsDir = resolveSkillsDir();
-    const skillDir = path18.join(skillsDir, name);
+    const skillDir = path21.join(skillsDir, name);
     if (!fs12.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path18.join(skillDir, "skill.yaml");
+    const yamlPath = path21.join(skillDir, "skill.yaml");
     let metadata = null;
     if (fs12.existsSync(yamlPath)) {
       try {
@@ -2585,15 +2985,15 @@ function createRunCommand2() {
     if (metadata?.phases && metadata.phases.length > 0) {
       const requested = opts.complexity ?? "auto";
       if (requested === "auto") {
-        const projectPath2 = opts.path ? path18.resolve(opts.path) : process.cwd();
+        const projectPath2 = opts.path ? path21.resolve(opts.path) : process.cwd();
         complexity = detectComplexity(projectPath2);
       } else {
         complexity = requested;
       }
     }
     let principles;
-    const projectPath = opts.path ? path18.resolve(opts.path) : process.cwd();
-    const principlesPath = path18.join(projectPath, "docs", "principles.md");
+    const projectPath = opts.path ? path21.resolve(opts.path) : process.cwd();
+    const principlesPath = path21.join(projectPath, "docs", "principles.md");
     if (fs12.existsSync(principlesPath)) {
       principles = fs12.readFileSync(principlesPath, "utf-8");
     }
@@ -2610,13 +3010,13 @@ function createRunCommand2() {
       }
       if (metadata?.state.persistent && metadata.state.files.length > 0) {
         for (const stateFilePath of metadata.state.files) {
-          const fullPath = path18.join(projectPath, stateFilePath);
+          const fullPath = path21.join(projectPath, stateFilePath);
           if (fs12.existsSync(fullPath)) {
             const stat = fs12.statSync(fullPath);
             if (stat.isDirectory()) {
-              const files = fs12.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs12.statSync(path18.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+              const files = fs12.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs12.statSync(path21.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
               if (files.length > 0) {
-                priorState = fs12.readFileSync(path18.join(fullPath, files[0].name), "utf-8");
+                priorState = fs12.readFileSync(path21.join(fullPath, files[0].name), "utf-8");
               }
             } else {
               priorState = fs12.readFileSync(fullPath, "utf-8");
@@ -2638,7 +3038,7 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path18.join(skillDir, "SKILL.md");
+    const skillMdPath = path21.join(skillDir, "SKILL.md");
     if (!fs12.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
@@ -2646,7 +3046,7 @@ function createRunCommand2() {
     }
     let content = fs12.readFileSync(skillMdPath, "utf-8");
     if (metadata?.state.persistent && opts.path) {
-      const stateFile = path18.join(projectPath, ".harness", "state.json");
+      const stateFile = path21.join(projectPath, ".harness", "state.json");
       if (fs12.existsSync(stateFile)) {
         const stateContent = fs12.readFileSync(stateFile, "utf-8");
         content += `
@@ -2665,9 +3065,9 @@ ${stateContent}
 }
 
 // src/commands/skill/validate.ts
-import { Command as Command20 } from "commander";
+import { Command as Command23 } from "commander";
 import * as fs13 from "fs";
-import * as path19 from "path";
+import * as path22 from "path";
 import { parse as parse5 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
@@ -2677,7 +3077,7 @@ var REQUIRED_SECTIONS = [
   "## Examples"
 ];
 function createValidateCommand3() {
-  return new Command20("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command23("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
     if (!fs13.existsSync(skillsDir)) {
@@ -2689,9 +3089,9 @@ function createValidateCommand3() {
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path19.join(skillsDir, name);
-      const yamlPath = path19.join(skillDir, "skill.yaml");
-      const skillMdPath = path19.join(skillDir, "SKILL.md");
+      const skillDir = path22.join(skillsDir, name);
+      const yamlPath = path22.join(skillDir, "skill.yaml");
+      const skillMdPath = path22.join(skillDir, "SKILL.md");
       if (!fs13.existsSync(yamlPath)) {
         errors.push(`${name}: missing skill.yaml`);
         continue;
@@ -2746,21 +3146,21 @@ function createValidateCommand3() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command21 } from "commander";
+import { Command as Command24 } from "commander";
 import * as fs14 from "fs";
-import * as path20 from "path";
+import * as path23 from "path";
 import { parse as parse6 } from "yaml";
 function createInfoCommand() {
-  return new Command21("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command24("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    const skillDir = path20.join(skillsDir, name);
+    const skillDir = path23.join(skillsDir, name);
     if (!fs14.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path20.join(skillDir, "skill.yaml");
+    const yamlPath = path23.join(skillDir, "skill.yaml");
     if (!fs14.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
@@ -2808,7 +3208,7 @@ function createInfoCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command22("skill").description("Skill management commands");
+  const command = new Command25("skill").description("Skill management commands");
   command.addCommand(createListCommand2());
   command.addCommand(createRunCommand2());
   command.addCommand(createValidateCommand3());
@@ -2817,17 +3217,17 @@ function createSkillCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command26 } from "commander";
+import { Command as Command30 } from "commander";
 
 // src/commands/state/show.ts
-import { Command as Command23 } from "commander";
-import * as path21 from "path";
+import { Command as Command26 } from "commander";
+import * as path24 from "path";
 import { loadState } from "@harness-engineering/core";
 function createShowCommand() {
-  return new Command23("show").description("Show current project state").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
+  return new Command26("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path21.resolve(opts.path);
-    const result = await loadState(projectPath);
+    const projectPath = path24.resolve(opts.path);
+    const result = await loadState(projectPath, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -2839,6 +3239,7 @@ function createShowCommand() {
     } else if (globalOpts.quiet) {
       console.log(JSON.stringify(state));
     } else {
+      if (opts.stream) console.log(`Stream:         ${opts.stream}`);
       console.log(`Schema Version: ${state.schemaVersion}`);
       if (state.position.phase) console.log(`Phase:          ${state.position.phase}`);
       if (state.position.task) console.log(`Task:           ${state.position.task}`);
@@ -2865,14 +3266,26 @@ Decisions: ${state.decisions.length}`);
 }
 
 // src/commands/state/reset.ts
-import { Command as Command24 } from "commander";
+import { Command as Command27 } from "commander";
 import * as fs15 from "fs";
-import * as path22 from "path";
+import * as path25 from "path";
 import * as readline from "readline";
+import { resolveStreamPath } from "@harness-engineering/core";
 function createResetCommand() {
-  return new Command24("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
-    const projectPath = path22.resolve(opts.path);
-    const statePath = path22.join(projectPath, ".harness", "state.json");
+  return new Command27("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
+    const projectPath = path25.resolve(opts.path);
+    let statePath;
+    if (opts.stream) {
+      const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
+      if (!streamResult.ok) {
+        logger.error(streamResult.error.message);
+        process.exit(ExitCode.ERROR);
+        return;
+      }
+      statePath = path25.join(streamResult.value, "state.json");
+    } else {
+      statePath = path25.join(projectPath, ".harness", "state.json");
+    }
     if (!fs15.existsSync(statePath)) {
       logger.info("No state file found. Nothing to reset.");
       process.exit(ExitCode.SUCCESS);
@@ -2880,8 +3293,8 @@ function createResetCommand() {
     }
     if (!opts.yes) {
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve18) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve18);
+      const answer = await new Promise((resolve22) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve22);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -2903,13 +3316,13 @@ function createResetCommand() {
 }
 
 // src/commands/state/learn.ts
-import { Command as Command25 } from "commander";
-import * as path23 from "path";
+import { Command as Command28 } from "commander";
+import * as path26 from "path";
 import { appendLearning } from "@harness-engineering/core";
 function createLearnCommand() {
-  return new Command25("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").action(async (message, opts, _cmd) => {
-    const projectPath = path23.resolve(opts.path);
-    const result = await appendLearning(projectPath, message);
+  return new Command28("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
+    const projectPath = path26.resolve(opts.path);
+    const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -2920,29 +3333,103 @@ function createLearnCommand() {
   });
 }
 
+// src/commands/state/streams.ts
+import { Command as Command29 } from "commander";
+import * as path27 from "path";
+import {
+  createStream,
+  listStreams,
+  archiveStream,
+  setActiveStream,
+  loadStreamIndex
+} from "@harness-engineering/core";
+function createStreamsCommand() {
+  const command = new Command29("streams").description("Manage state streams");
+  command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path27.resolve(opts.path);
+    const indexResult = await loadStreamIndex(projectPath);
+    const result = await listStreams(projectPath);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    const active = indexResult.ok ? indexResult.value.activeStream : null;
+    if (globalOpts.json) {
+      logger.raw({ activeStream: active, streams: result.value });
+    } else {
+      if (result.value.length === 0) {
+        console.log("No streams found.");
+      }
+      for (const s of result.value) {
+        const marker = s.name === active ? " (active)" : "";
+        const branch = s.branch ? ` [${s.branch}]` : "";
+        console.log(`  ${s.name}${marker}${branch} \u2014 last active: ${s.lastActiveAt}`);
+      }
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await createStream(projectPath, name, opts.branch);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Stream '${name}' created.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await archiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Stream '${name}' archived.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await setActiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Active stream set to '${name}'.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command26("state").description("Project state management commands");
+  const command = new Command30("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
+  command.addCommand(createStreamsCommand());
   return command;
 }
 
 // src/commands/check-phase-gate.ts
-import { Command as Command27 } from "commander";
-import * as path24 from "path";
+import { Command as Command31 } from "commander";
+import * as path28 from "path";
 import * as fs16 from "fs";
-import { Ok as Ok16 } from "@harness-engineering/core";
+import { Ok as Ok18 } from "@harness-engineering/core";
 function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
-  const relImpl = path24.relative(cwd, implFile);
+  const relImpl = path28.relative(cwd, implFile);
   const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
   const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
   const segments = afterBase.split("/");
   const firstSegment = segments[0] ?? "";
-  const feature = segments.length > 1 ? firstSegment : path24.basename(firstSegment, path24.extname(firstSegment));
+  const feature = segments.length > 1 ? firstSegment : path28.basename(firstSegment, path28.extname(firstSegment));
   const specRelative = specPattern.replace("{feature}", feature);
-  return path24.resolve(cwd, specRelative);
+  return path28.resolve(cwd, specRelative);
 }
 async function runCheckPhaseGate(options) {
   const configResult = resolveConfig(options.configPath);
@@ -2950,9 +3437,9 @@ async function runCheckPhaseGate(options) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path24.dirname(path24.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path28.dirname(path28.resolve(options.configPath)) : process.cwd());
   if (!config.phaseGates?.enabled) {
-    return Ok16({
+    return Ok18({
       pass: true,
       skipped: true,
       missingSpecs: [],
@@ -2969,14 +3456,14 @@ async function runCheckPhaseGate(options) {
       const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
       if (!fs16.existsSync(expectedSpec)) {
         missingSpecs.push({
-          implFile: path24.relative(cwd, implFile),
-          expectedSpec: path24.relative(cwd, expectedSpec)
+          implFile: path28.relative(cwd, implFile),
+          expectedSpec: path28.relative(cwd, expectedSpec)
         });
       }
     }
   }
   const pass = missingSpecs.length === 0;
-  return Ok16({
+  return Ok18({
     pass,
     skipped: false,
     severity: phaseGates.severity,
@@ -2985,7 +3472,7 @@ async function runCheckPhaseGate(options) {
   });
 }
 function createCheckPhaseGateCommand() {
-  const command = new Command27("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
+  const command = new Command31("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const formatter = new OutputFormatter(mode);
@@ -3039,15 +3526,15 @@ function createCheckPhaseGateCommand() {
 }
 
 // src/commands/generate-slash-commands.ts
-import { Command as Command28 } from "commander";
+import { Command as Command32 } from "commander";
 import fs19 from "fs";
-import path27 from "path";
+import path31 from "path";
 import os2 from "os";
 import readline2 from "readline";
 
 // src/slash-commands/normalize.ts
 import fs17 from "fs";
-import path25 from "path";
+import path29 from "path";
 import { parse as parse7 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
@@ -3071,7 +3558,7 @@ function normalizeSkills(skillSources, platforms) {
     if (!fs17.existsSync(skillsDir)) continue;
     const entries = fs17.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path25.join(skillsDir, entry.name, "skill.yaml");
+      const yamlPath = path29.join(skillsDir, entry.name, "skill.yaml");
       if (!fs17.existsSync(yamlPath)) continue;
       let raw;
       try {
@@ -3099,15 +3586,15 @@ function normalizeSkills(skillSources, platforms) {
         continue;
       }
       nameMap.set(normalized, { skillName: meta.name, source });
-      const skillMdPath = path25.join(skillsDir, entry.name, "SKILL.md");
+      const skillMdPath = path29.join(skillsDir, entry.name, "SKILL.md");
       const skillMdContent = fs17.existsSync(skillMdPath) ? fs17.readFileSync(skillMdPath, "utf-8") : "";
-      const skillMdRelative = path25.relative(
+      const skillMdRelative = path29.relative(
         process.cwd(),
-        path25.join(skillsDir, entry.name, "SKILL.md")
+        path29.join(skillsDir, entry.name, "SKILL.md")
       );
-      const skillYamlRelative = path25.relative(
+      const skillYamlRelative = path29.relative(
         process.cwd(),
-        path25.join(skillsDir, entry.name, "skill.yaml")
+        path29.join(skillsDir, entry.name, "skill.yaml")
       );
       const args = (meta.cli?.args ?? []).map((a) => ({
         name: a.name,
@@ -3277,7 +3764,7 @@ function renderGemini(spec, skillMdContent, skillYamlContent) {
 
 // src/slash-commands/sync.ts
 import fs18 from "fs";
-import path26 from "path";
+import path30 from "path";
 
 // src/agent-definitions/constants.ts
 var GENERATED_HEADER_AGENT = "<!-- Generated by harness generate-agent-definitions. Do not edit. -->";
@@ -3289,7 +3776,7 @@ function computeSyncPlan(outputDir, rendered) {
   const removed = [];
   const unchanged = [];
   for (const [filename, content] of rendered) {
-    const filePath = path26.join(outputDir, filename);
+    const filePath = path30.join(outputDir, filename);
     if (!fs18.existsSync(filePath)) {
       added.push(filename);
     } else {
@@ -3303,12 +3790,12 @@ function computeSyncPlan(outputDir, rendered) {
   }
   if (fs18.existsSync(outputDir)) {
     const existing = fs18.readdirSync(outputDir).filter((f) => {
-      const stat = fs18.statSync(path26.join(outputDir, f));
+      const stat = fs18.statSync(path30.join(outputDir, f));
       return stat.isFile();
     });
     for (const filename of existing) {
       if (rendered.has(filename)) continue;
-      const content = fs18.readFileSync(path26.join(outputDir, filename), "utf-8");
+      const content = fs18.readFileSync(path30.join(outputDir, filename), "utf-8");
       if (content.includes(GENERATED_HEADER_CLAUDE) || content.includes(GENERATED_HEADER_GEMINI) || content.includes(GENERATED_HEADER_AGENT)) {
         removed.push(filename);
       }
@@ -3321,12 +3808,12 @@ function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
   for (const filename of [...plan.added, ...plan.updated]) {
     const content = rendered.get(filename);
     if (content !== void 0) {
-      fs18.writeFileSync(path26.join(outputDir, filename), content);
+      fs18.writeFileSync(path30.join(outputDir, filename), content);
     }
   }
   if (deleteOrphans) {
     for (const filename of plan.removed) {
-      const filePath = path26.join(outputDir, filename);
+      const filePath = path30.join(outputDir, filename);
       if (fs18.existsSync(filePath)) {
         fs18.unlinkSync(filePath);
       }
@@ -3337,24 +3824,24 @@ function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path27.join(opts.output, "harness");
+    return path31.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os2.homedir();
-    return platform === "claude-code" ? path27.join(home, ".claude", "commands", "harness") : path27.join(home, ".gemini", "commands", "harness");
+    return platform === "claude-code" ? path31.join(home, ".claude", "commands", "harness") : path31.join(home, ".gemini", "commands", "harness");
   }
-  return platform === "claude-code" ? path27.join("agents", "commands", "claude-code", "harness") : path27.join("agents", "commands", "gemini-cli", "harness");
+  return platform === "claude-code" ? path31.join("agents", "commands", "claude-code", "harness") : path31.join("agents", "commands", "gemini-cli", "harness");
 }
 function fileExtension(platform) {
   return platform === "claude-code" ? ".md" : ".toml";
 }
 async function confirmDeletion(files) {
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve18) => {
+  return new Promise((resolve22) => {
     rl.question(`
 Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
       rl.close();
-      resolve18(answer.toLowerCase() === "y");
+      resolve22(answer.toLowerCase() === "y");
     });
   });
 }
@@ -3369,7 +3856,7 @@ function generateSlashCommands(opts) {
     }
     if (opts.includeGlobal || skillSources.length === 0) {
       const globalDir = resolveGlobalSkillsDir();
-      if (!projectDir || path27.resolve(globalDir) !== path27.resolve(projectDir)) {
+      if (!projectDir || path31.resolve(globalDir) !== path31.resolve(projectDir)) {
         skillSources.push({ dir: globalDir, source: "global" });
       }
     }
@@ -3391,7 +3878,7 @@ function generateSlashCommands(opts) {
             executionContext: spec.prompt.executionContext.split("\n").map((line) => {
               if (line.startsWith("@")) {
                 const relPath = line.slice(1);
-                return `@${path27.resolve(relPath)}`;
+                return `@${path31.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -3399,8 +3886,8 @@ function generateSlashCommands(opts) {
         } : spec;
         rendered.set(filename, renderClaudeCode(renderSpec));
       } else {
-        const mdPath = path27.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-        const yamlPath = path27.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdPath = path31.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path31.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
         const mdContent = fs19.existsSync(mdPath) ? fs19.readFileSync(mdPath, "utf-8") : "";
         const yamlContent = fs19.existsSync(yamlPath) ? fs19.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
@@ -3428,7 +3915,7 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (shouldDelete) {
       for (const filename of result.removed) {
-        const filePath = path27.join(result.outputDir, filename);
+        const filePath = path31.join(result.outputDir, filename);
         if (fs19.existsSync(filePath)) {
           fs19.unlinkSync(filePath);
         }
@@ -3437,7 +3924,7 @@ async function handleOrphanDeletion(results, opts) {
   }
 }
 function createGenerateSlashCommandsCommand() {
-  return new Command28("generate-slash-commands").description(
+  return new Command32("generate-slash-commands").description(
     "Generate native slash commands for Claude Code and Gemini CLI from skill metadata"
   ).option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global config directories", false).option("--include-global", "Include built-in global skills alongside project skills", false).option("--output <dir>", "Custom output directory").option("--skills-dir <path>", "Skills directory to scan").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -3502,10 +3989,10 @@ ${result.platform} \u2192 ${result.outputDir}`);
 }
 
 // src/commands/ci/index.ts
-import { Command as Command31 } from "commander";
+import { Command as Command35 } from "commander";
 
 // src/commands/ci/check.ts
-import { Command as Command29 } from "commander";
+import { Command as Command33 } from "commander";
 import { runCIChecks } from "@harness-engineering/core";
 var VALID_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 async function runCICheck(options) {
@@ -3537,7 +4024,7 @@ function parseFailOn(failOn) {
   return "error";
 }
 function createCheckCommand() {
-  return new Command29("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate)").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 Command33("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const skip = parseSkip(opts.skip);
@@ -3581,10 +4068,10 @@ function createCheckCommand() {
 }
 
 // src/commands/ci/init.ts
-import { Command as Command30 } from "commander";
+import { Command as Command34 } from "commander";
 import * as fs20 from "fs";
-import * as path28 from "path";
-import { Ok as Ok17, Err as Err14 } from "@harness-engineering/core";
+import * as path32 from "path";
+import { Ok as Ok19, Err as Err14 } from "@harness-engineering/core";
 var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 function buildSkipFlag(checks) {
   if (!checks) return "";
@@ -3670,7 +4157,7 @@ function generateCIConfig(options) {
   if (!entry) {
     return Err14(new CLIError(`Unknown platform: ${platform}`, ExitCode.ERROR));
   }
-  return Ok17({
+  return Ok19({
     filename: entry.filename,
     content: entry.generate(skipFlag)
   });
@@ -3681,7 +4168,7 @@ function detectPlatform() {
   return null;
 }
 function createInitCommand2() {
-  return new Command30("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 Command34("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platform = opts.platform ?? detectPlatform() ?? "generic";
     const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
@@ -3693,8 +4180,8 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path28.resolve(filename);
-    const dir = path28.dirname(targetPath);
+    const targetPath = path32.resolve(filename);
+    const dir = path32.dirname(targetPath);
     fs20.mkdirSync(dir, { recursive: true });
     fs20.writeFileSync(targetPath, content);
     if (platform === "generic") {
@@ -3711,15 +4198,15 @@ function createInitCommand2() {
 
 // src/commands/ci/index.ts
 function createCICommand() {
-  const command = new Command31("ci").description("CI/CD integration commands");
+  const command = new Command35("ci").description("CI/CD integration commands");
   command.addCommand(createCheckCommand());
   command.addCommand(createInitCommand2());
   return command;
 }
 
 // src/commands/update.ts
-import { Command as Command32 } from "commander";
-import { execSync as execSync3 } from "child_process";
+import { Command as Command36 } from "commander";
+import { execSync as execSync4 } from "child_process";
 import { realpathSync } from "fs";
 import readline3 from "readline";
 import chalk4 from "chalk";
@@ -3739,7 +4226,7 @@ function detectPackageManager() {
   return "npm";
 }
 function getLatestVersion(pkg = "@harness-engineering/cli") {
-  const output = execSync3(`npm view ${pkg} dist-tags.latest`, {
+  const output = execSync4(`npm view ${pkg} dist-tags.latest`, {
     encoding: "utf-8",
     timeout: 15e3
   });
@@ -3747,7 +4234,7 @@ function getLatestVersion(pkg = "@harness-engineering/cli") {
 }
 function getInstalledVersion(pm) {
   try {
-    const output = execSync3(`${pm} list -g @harness-engineering/cli --json`, {
+    const output = execSync4(`${pm} list -g @harness-engineering/cli --json`, {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -3760,7 +4247,7 @@ function getInstalledVersion(pm) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execSync3(`${pm} list -g --json`, {
+    const output = execSync4(`${pm} list -g --json`, {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -3776,15 +4263,15 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve18) => {
+  return new Promise((resolve22) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve18(answer.trim().toLowerCase());
+      resolve22(answer.trim().toLowerCase());
     });
   });
 }
 function createUpdateCommand() {
-  return new Command32("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
+  return new Command36("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const pm = detectPackageManager();
     if (globalOpts.verbose) {
@@ -3827,7 +4314,7 @@ function createUpdateCommand() {
     }
     try {
       logger.info("Updating packages...");
-      execSync3(installCmd, { stdio: "inherit", timeout: 12e4 });
+      execSync4(installCmd, { stdio: "inherit", timeout: 12e4 });
       console.log("");
       logger.success("Update complete");
     } catch {
@@ -3837,15 +4324,15 @@ function createUpdateCommand() {
       process.exit(ExitCode.ERROR);
     }
     console.log("");
-    const regenAnswer = await prompt("Regenerate slash commands? (y/N) ");
+    const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (y/N) ");
     if (regenAnswer === "y" || regenAnswer === "yes") {
       const scopeAnswer = await prompt("Generate for (g)lobal or (l)ocal project? (g/l) ");
       const globalFlag = scopeAnswer === "g" || scopeAnswer === "global" ? " --global" : "";
       try {
-        execSync3(`harness generate-slash-commands${globalFlag}`, { stdio: "inherit" });
+        execSync4(`harness generate${globalFlag}`, { stdio: "inherit" });
       } catch {
-        logger.warn("Slash command generation failed. Run manually:");
-        console.log(`  ${chalk4.cyan(`harness generate-slash-commands${globalFlag}`)}`);
+        logger.warn("Generation failed. Run manually:");
+        console.log(`  ${chalk4.cyan(`harness generate${globalFlag}`)}`);
       }
     }
     process.exit(ExitCode.SUCCESS);
@@ -3853,9 +4340,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/generate-agent-definitions.ts
-import { Command as Command33 } from "commander";
+import { Command as Command37 } from "commander";
 import * as fs21 from "fs";
-import * as path29 from "path";
+import * as path33 from "path";
 import * as os3 from "os";
 
 // src/agent-definitions/generator.ts
@@ -3991,17 +4478,17 @@ function renderGeminiAgent(def) {
 // src/commands/generate-agent-definitions.ts
 function resolveOutputDir2(platform, opts) {
   if (opts.output) {
-    return platform === "claude-code" ? path29.join(opts.output, "claude-code") : path29.join(opts.output, "gemini-cli");
+    return platform === "claude-code" ? path33.join(opts.output, "claude-code") : path33.join(opts.output, "gemini-cli");
   }
   if (opts.global) {
     const home = os3.homedir();
-    return platform === "claude-code" ? path29.join(home, ".claude", "agents") : path29.join(home, ".gemini", "agents");
+    return platform === "claude-code" ? path33.join(home, ".claude", "agents") : path33.join(home, ".gemini", "agents");
   }
-  return platform === "claude-code" ? path29.join("agents", "agents", "claude-code") : path29.join("agents", "agents", "gemini-cli");
+  return platform === "claude-code" ? path33.join("agents", "agents", "claude-code") : path33.join("agents", "agents", "gemini-cli");
 }
 function loadSkillContent(skillName) {
   const skillsDir = resolveSkillsDir();
-  const skillMdPath = path29.join(skillsDir, skillName, "SKILL.md");
+  const skillMdPath = path33.join(skillsDir, skillName, "SKILL.md");
   if (!fs21.existsSync(skillMdPath)) return null;
   return fs21.readFileSync(skillMdPath, "utf-8");
 }
@@ -4047,7 +4534,7 @@ function generateAgentDefinitions(opts) {
   return results;
 }
 function createGenerateAgentDefinitionsCommand() {
-  return new Command33("generate-agent-definitions").description("Generate agent definition files from personas for Claude Code and Gemini CLI").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global agent directories", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).action(async (opts, cmd) => {
+  return new Command37("generate-agent-definitions").description("Generate agent definition files from personas for Claude Code and Gemini CLI").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global agent directories", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platforms = opts.platforms.split(",").map((p) => p.trim());
     for (const p of platforms) {
@@ -4095,9 +4582,9 @@ ${result.platform} \u2192 ${result.outputDir}`);
 }
 
 // src/commands/generate.ts
-import { Command as Command34 } from "commander";
+import { Command as Command38 } from "commander";
 function createGenerateCommand3() {
-  return new Command34("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 Command38("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platforms = opts.platforms.split(",").map((p) => p.trim());
     for (const p of platforms) {
@@ -4156,8 +4643,8 @@ function createGenerateCommand3() {
 }
 
 // src/commands/graph/scan.ts
-import { Command as Command35 } from "commander";
-import * as path30 from "path";
+import { Command as Command39 } from "commander";
+import * as path34 from "path";
 async function runScan(projectPath) {
   const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("@harness-engineering/graph");
   const store = new GraphStore();
@@ -4170,13 +4657,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path30.join(projectPath, ".harness", "graph");
+  const graphDir = path34.join(projectPath, ".harness", "graph");
   await store.save(graphDir);
   return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
 }
 function createScanCommand() {
-  return new Command35("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
-    const projectPath = path30.resolve(inputPath);
+  return new Command39("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path34.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -4195,12 +4682,12 @@ function createScanCommand() {
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command36 } from "commander";
-import * as path31 from "path";
+import { Command as Command40 } from "commander";
+import * as path35 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
     const fs22 = await import("fs/promises");
-    const configPath = path31.join(projectPath, "harness.config.json");
+    const configPath = path35.join(projectPath, "harness.config.json");
     const config = JSON.parse(await fs22.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
@@ -4241,7 +4728,7 @@ async function runIngest(projectPath, source, opts) {
     JiraConnector,
     SlackConnector
   } = await import("@harness-engineering/graph");
-  const graphDir = path31.join(projectPath, ".harness", "graph");
+  const graphDir = path35.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -4302,13 +4789,13 @@ async function runIngest(projectPath, source, opts) {
   return result;
 }
 function createIngestCommand() {
-  return new Command36("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
+  return new Command40("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
     if (!opts.source && !opts.all) {
       console.error("Error: --source or --all is required");
       process.exit(1);
     }
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path31.resolve(globalOpts.config ? path31.dirname(globalOpts.config) : ".");
+    const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -4330,12 +4817,12 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/query.ts
-import { Command as Command37 } from "commander";
-import * as path32 from "path";
+import { Command as Command41 } from "commander";
+import * as path36 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
   const { GraphStore, ContextQL } = await import("@harness-engineering/graph");
   const store = new GraphStore();
-  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const graphDir = path36.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -4349,9 +4836,9 @@ async function runQuery(projectPath, rootNodeId, opts) {
   return cql.execute(params);
 }
 function createQueryCommand() {
-  return new Command37("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 Command41("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path32.resolve(globalOpts.config ? path32.dirname(globalOpts.config) : ".");
+    const projectPath = path36.resolve(globalOpts.config ? path36.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -4377,18 +4864,18 @@ function createQueryCommand() {
 }
 
 // src/commands/graph/index.ts
-import { Command as Command38 } from "commander";
+import { Command as Command42 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path33 from "path";
+import * as path37 from "path";
 async function runGraphStatus(projectPath) {
   const { GraphStore } = await import("@harness-engineering/graph");
-  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const graphDir = path37.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 fs22 = await import("fs/promises");
-  const metaPath = path33.join(graphDir, "metadata.json");
+  const metaPath = path37.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
     const meta = JSON.parse(await fs22.readFile(metaPath, "utf-8"));
@@ -4402,7 +4889,7 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path33.join(graphDir, "sync-metadata.json");
+    const syncMetaPath = path37.join(graphDir, "sync-metadata.json");
     const syncMeta = JSON.parse(await fs22.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
@@ -4420,10 +4907,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path34 from "path";
+import * as path38 from "path";
 async function runGraphExport(projectPath, format) {
   const { GraphStore } = await import("@harness-engineering/graph");
-  const graphDir = path34.join(projectPath, ".harness", "graph");
+  const graphDir = path38.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.");
@@ -4452,13 +4939,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path35 from "path";
+import * as path39 from "path";
 function createGraphCommand() {
-  const graph = new Command38("graph").description("Knowledge graph management");
+  const graph = new Command42("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
     try {
       const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
+      const projectPath = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -4485,7 +4972,7 @@ function createGraphCommand() {
   });
   graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
+    const projectPath = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);
@@ -4499,11 +4986,14 @@ function createGraphCommand() {
 
 // src/index.ts
 function createProgram() {
-  const program = new Command39();
+  const program = new Command43();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
   program.addCommand(createCheckDocsCommand());
+  program.addCommand(createCheckPerfCommand());
+  program.addCommand(createCheckSecurityCommand());
+  program.addCommand(createPerfCommand());
   program.addCommand(createInitCommand());
   program.addCommand(createCleanupCommand());
   program.addCommand(createFixDriftCommand());