@harness-engineering/cli 1.25.7 → 1.26.1

package/dist/{chunk-SZ3Q4XEO.js → chunk-AMRC4FU2.js}

@@ -1,19 +1,19 @@
 import {
   generateAgentsMd
-} from "./chunk-IT2KORSK.js";
+} from "./chunk-ZN6ROTYP.js";
 import {
   generateCIWorkflow
-} from "./chunk-KVJZQ2MV.js";
+} from "./chunk-ORNEK65Y.js";
 import {
   TemplateEngine
-} from "./chunk-K533WNZG.js";
+} from "./chunk-B66LRB5M.js";
 import {
   generate,
   validate
 } from "./chunk-CQ553GZO.js";
 import {
   generateRuntime
-} from "./chunk-K35D7HF3.js";
+} from "./chunk-N6B6RKQQ.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -28,24 +28,25 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-LXPRO2FH.js";
+} from "./chunk-FUND5WJR.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-MCDCZMKN.js";
+} from "./chunk-TY2ESLVL.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-FRDS4XGD.js";
+} from "./chunk-JV4Y2U5F.js";
 import {
   createScanCommand
-} from "./chunk-E5Z6NTTQ.js";
+} from "./chunk-Q3ZLVMQM.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
+  createAdviseSkillsCommand,
   createGenerateSlashCommandsCommand,
   ensureHarnessGitignore,
   generateSlashCommands,
@@ -56,11 +57,11 @@ import {
   loadOrRebuildIndex,
   persistToolingConfig,
   recommend
-} from "./chunk-JJQ3TW2E.js";
+} from "./chunk-2BPPS6YQ.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-TQRCODRJ.js";
+} from "./chunk-VKS3F46M.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -74,7 +75,7 @@ import {
 } from "./chunk-6B6UN6SG.js";
 import {
   loadGraphStore
-} from "./chunk-JPZY7ZQX.js";
+} from "./chunk-OLW7BJ5N.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -148,20 +149,20 @@ import {
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-ZIYLIYN4.js";
+} from "./chunk-YC4EYIER.js";
 import {
   Err,
   Ok
 } from "./chunk-RL4VMEXL.js";
 import {
   createCreateSkillCommand
-} from "./chunk-RRHUCDRD.js";
-import {
-  logger
-} from "./chunk-EBJQ6N4M.js";
+} from "./chunk-ZP5E7YET.js";
 import {
   SkillMetadataSchema
 } from "./chunk-HIK6OEUF.js";
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
 import {
   CLIError,
   ExitCode,
@@ -173,7 +174,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command84 } from "commander";
+import { Command as Command85 } from "commander";
 
 // src/commands/add.ts
 init_dist();
@@ -264,7 +265,7 @@ function addDoc(name, cwd, configResult, created) {
   return Ok(void 0);
 }
 async function addSkill(name, cwd, created) {
-  const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-6QWJHQYS.js");
+  const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-4T5CBSJ2.js");
   generateSkillFiles2({
     name,
     description: `${name} skill`,
@@ -362,7 +363,7 @@ function registerSkillsCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-ZV6GO6FA.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-CJDGASPP.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -398,7 +399,7 @@ function registerRecentCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords } = await import("./dist-ZV6GO6FA.js");
+    const { readAdoptionRecords } = await import("./dist-CJDGASPP.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -476,7 +477,7 @@ function registerSkillCommand(adoption) {
   adoption.command("skill <name>").description("Show detail for a specific skill").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-ZV6GO6FA.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-CJDGASPP.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -2765,7 +2766,7 @@ import { Command as Command25 } from "commander";
 // src/commands/graph/status.ts
 import * as path15 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-HPWNWCT6.js");
+  const { GraphStore } = await import("./dist-NCNAXUFD.js");
   const graphDir = path15.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
@@ -2805,7 +2806,7 @@ async function runGraphStatus(projectPath) {
 // src/commands/graph/export.ts
 import * as path16 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-HPWNWCT6.js");
+  const { GraphStore } = await import("./dist-NCNAXUFD.js");
   const graphDir = path16.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
@@ -2841,7 +2842,7 @@ import * as path19 from "path";
 import { Command as Command23 } from "commander";
 import * as path17 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-HPWNWCT6.js");
+  const { GraphStore, ContextQL } = await import("./dist-NCNAXUFD.js");
   const store = new GraphStore();
   const graphDir = path17.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -2935,7 +2936,7 @@ async function runIngest(projectPath, source, opts) {
     SlackConnector,
     CIConnector,
     ConfluenceConnector
-  } = await import("./dist-HPWNWCT6.js");
+  } = await import("./dist-NCNAXUFD.js");
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
@@ -2945,6 +2946,9 @@ async function runIngest(projectPath, source, opts) {
     new TopologicalLinker(store).link();
     const knowledgeResult = await new KnowledgeIngestor(store).ingestAll(projectPath);
     const gitResult = await new GitIngestor(store).ingest(projectPath);
+    const { createExtractionRunner } = await import("./dist-NCNAXUFD.js");
+    const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
+    const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
     const connectorMap = {
       jira: () => new JiraConnector(),
@@ -2958,7 +2962,13 @@ async function runIngest(projectPath, source, opts) {
     }
     const connectorResult = await syncManager.syncAll();
     await store.save(graphDir);
-    const merged = mergeResults(codeResult, knowledgeResult, gitResult, connectorResult);
+    const merged = mergeResults(
+      codeResult,
+      knowledgeResult,
+      gitResult,
+      signalsResult,
+      connectorResult
+    );
     return { ...merged, durationMs: Date.now() - startMs };
   }
   let result;
@@ -2973,11 +2983,17 @@ async function runIngest(projectPath, source, opts) {
     case "git":
       result = await new GitIngestor(store).ingest(projectPath);
       break;
+    case "business-signals": {
+      const { createExtractionRunner } = await import("./dist-NCNAXUFD.js");
+      const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
+      result = await createExtractionRunner().run(projectPath, store, extractedDir);
+      break;
+    }
     default: {
       const knownConnectors = ["jira", "slack", "ci", "confluence"];
       if (!knownConnectors.includes(source)) {
         throw new Error(
-          `Unknown source: ${source}. Available: code, knowledge, git, jira, slack, ci, confluence`
+          `Unknown source: ${source}. Available: code, knowledge, git, business-signals, jira, slack, ci, confluence`
         );
       }
       if (!SyncManager) {
@@ -3005,7 +3021,7 @@ async function runIngest(projectPath, source, opts) {
 function createIngestCommand() {
   return new Command24("ingest").description("Ingest data into the knowledge graph").option(
     "--source <name>",
-    "Source to ingest (code, knowledge, git, jira, slack, ci, confluence)"
+    "Source to ingest (code, knowledge, git, business-signals, jira, slack, ci, confluence)"
   ).option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
     if (!opts.source && !opts.all) {
       console.error("Error: --source or --all is required");
@@ -3820,6 +3836,7 @@ var ALL_MCP_TOOLS = [
   "check_traceability",
   "predict_failures",
   "recommend_skills",
+  "advise_skills",
   "compute_blast_radius",
   "dispatch_skills",
   "compact",
@@ -5252,15 +5269,149 @@ function createIntegrationsCommand() {
   return command;
 }
 
+// src/commands/knowledge-pipeline.ts
+import { Command as Command41 } from "commander";
+import * as path38 from "path";
+import chalk6 from "chalk";
+function createKnowledgePipelineCommand() {
+  return new Command41("knowledge-pipeline").description("Run knowledge extraction, drift detection, and gap analysis").option("--fix", "Enable convergence-based auto-remediation (default: detect-only)").option("--ci", "Non-interactive mode \u2014 apply safe fixes only, report everything else").option("--domain <name>", "Limit pipeline to a specific knowledge domain").option("--drift-check", "Exit 1 if unresolved drift exists (CI gate mode)").option("--analyze-images", "Enable vision model analysis of image files").option("--image-paths <paths>", "Comma-separated image file paths for analysis").option("--coverage", "Display per-domain coverage report").option("--check-contradictions", "Display cross-source contradiction report").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectDir = globalOpts.cwd ?? process.cwd();
+    try {
+      const graphDir = path38.join(projectDir, ".harness", "graph");
+      const fs41 = await import("fs/promises");
+      await fs41.mkdir(graphDir, { recursive: true });
+      const { GraphStore, KnowledgePipelineRunner } = await import("./dist-NCNAXUFD.js");
+      const store = new GraphStore();
+      try {
+        await store.load(graphDir);
+      } catch {
+      }
+      const pipelineOpts = {
+        projectDir,
+        fix: Boolean(opts.fix),
+        ci: Boolean(opts.ci),
+        ...opts.domain ? { domain: opts.domain } : {},
+        graphDir,
+        analyzeImages: Boolean(opts.analyzeImages)
+      };
+      if (opts.imagePaths) {
+        pipelineOpts.imagePaths = opts.imagePaths.split(",").map((p) => p.trim());
+      }
+      if (opts.analyzeImages) {
+        try {
+          const intelligence = await import("@harness-engineering/intelligence");
+          const ProviderClass = intelligence.AnthropicAnalysisProvider;
+          pipelineOpts.analysisProvider = new ProviderClass();
+        } catch {
+          logger.error(
+            "Image analysis requires @harness-engineering/intelligence with ANTHROPIC_API_KEY set."
+          );
+          process.exit(1);
+        }
+      }
+      const runner = new KnowledgePipelineRunner(store);
+      const result = await runner.run(
+        pipelineOpts
+      );
+      if (globalOpts.json) {
+        console.log(
+          JSON.stringify(
+            {
+              verdict: result.verdict,
+              driftScore: result.driftScore,
+              iterations: result.iterations,
+              findings: result.findings,
+              extraction: result.extraction,
+              gaps: {
+                domains: result.gaps.domains.length,
+                totalEntries: result.gaps.totalEntries
+              },
+              remediations: result.remediations,
+              contradictions: {
+                count: result.contradictions.contradictions.length,
+                sourcePairCounts: result.contradictions.sourcePairCounts
+              },
+              coverage: {
+                overallScore: result.coverage.overallScore,
+                overallGrade: result.coverage.overallGrade,
+                domains: result.coverage.domains.length
+              }
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        const verdictColor = result.verdict === "pass" ? chalk6.green("PASS") : result.verdict === "warn" ? chalk6.yellow("WARN") : chalk6.red("FAIL");
+        console.log("");
+        console.log(`KNOWLEDGE PIPELINE -- Verdict: ${verdictColor}`);
+        console.log("");
+        console.log(`  Drift Score: ${result.driftScore.toFixed(2)}`);
+        console.log(
+          `  Findings: ${result.findings.new} new, ${result.findings.stale} stale, ${result.findings.drifted} drifted, ${result.findings.contradicting} contradicting`
+        );
+        console.log(
+          `  Extraction: ${result.extraction.codeSignals} code signals, ${result.extraction.diagrams} diagrams, ${result.extraction.linkerFacts} linker facts, ${result.extraction.businessKnowledge} business knowledge, ${result.extraction.images} images`
+        );
+        console.log(
+          `  Gaps: ${result.gaps.domains.length} domains, ${result.gaps.totalEntries} total entries`
+        );
+        if (result.iterations > 1) {
+          console.log(`  Convergence: ${result.iterations} iterations`);
+        }
+        if (result.remediations.length > 0) {
+          console.log(`  Remediations: ${result.remediations.length} applied`);
+        }
+        if (opts.checkContradictions || result.contradictions.contradictions.length > 0) {
+          console.log("");
+          console.log(
+            `  Contradictions: ${result.contradictions.contradictions.length} detected across ${result.contradictions.totalChecked} knowledge nodes`
+          );
+          for (const c of result.contradictions.contradictions) {
+            console.log(
+              `    ${chalk6.red("!")} ${c.description} [${c.conflictType}] (${c.severity})`
+            );
+          }
+        }
+        if (opts.coverage || result.coverage.domains.length > 0) {
+          console.log("");
+          console.log(
+            `  Coverage: ${result.coverage.overallGrade} (${result.coverage.overallScore}/100)`
+          );
+          for (const d of result.coverage.domains) {
+            console.log(
+              `    ${d.domain}: ${d.grade} (${d.score}/100) \u2014 ${d.knowledgeEntries} knowledge, ${d.linkedEntities}/${d.codeEntities} code linked`
+            );
+          }
+        }
+        console.log("");
+      }
+      const unresolvedDrift = result.findings.drifted + result.findings.stale + result.findings.contradicting;
+      if (opts.driftCheck && unresolvedDrift > 0) {
+        logger.error(
+          `${unresolvedDrift} unresolved drift findings. Run /harness:knowledge-pipeline --fix to remediate.`
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      logger.error(
+        `Knowledge pipeline failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/learnings/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command43 } from "commander";
 
 // src/commands/learnings/prune.ts
 init_dist();
-import { Command as Command41 } from "commander";
-import * as path38 from "path";
+import { Command as Command42 } from "commander";
+import * as path39 from "path";
 async function handlePrune(opts) {
-  const projectPath = path38.resolve(opts.path);
+  const projectPath = path39.resolve(opts.path);
   const result = await pruneLearnings(projectPath, opts.stream);
   if (!result.ok) {
     logger.error(result.error.message);
@@ -5299,23 +5450,23 @@ function printPatternProposals(patterns) {
   );
 }
 function createPruneCommand() {
-  return new Command41("prune").description(
+  return new Command42("prune").description(
     "Analyze global learnings for patterns, present improvement proposals, and archive old entries"
   ).option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(handlePrune);
 }
 
 // src/commands/learnings/index.ts
 function createLearningsCommand() {
-  const command = new Command42("learnings").description("Learnings management commands");
+  const command = new Command43("learnings").description("Learnings management commands");
   command.addCommand(createPruneCommand());
   return command;
 }
 
 // src/commands/linter/index.ts
-import { Command as Command45 } from "commander";
+import { Command as Command46 } from "commander";
 
 // src/commands/linter/generate.ts
-import { Command as Command43 } from "commander";
+import { Command as Command44 } from "commander";
 function formatGenerateError(e) {
   switch (e.type) {
     case "parse":
@@ -5359,7 +5510,7 @@ function handleSuccess(result, useJson) {
 Generated ${result.rulesGenerated.length} rules to ${result.outputDir}`);
 }
 function createGenerateCommand2() {
-  return new Command43("generate").description("Generate ESLint rules from harness-linter.yml").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("-o, --output <dir>", "Override output directory").option("--clean", "Remove existing files before generating").option("--dry-run", "Preview without writing files").option("--json", "Output as JSON").option("--verbose", "Show detailed output").action(async (options) => {
+  return new Command44("generate").description("Generate ESLint rules from harness-linter.yml").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("-o, --output <dir>", "Override output directory").option("--clean", "Remove existing files before generating").option("--dry-run", "Preview without writing files").option("--json", "Output as JSON").option("--verbose", "Show detailed output").action(async (options) => {
     try {
       if (options.verbose) logger.info(`Parsing config: ${options.config}`);
       const result = await generate({
@@ -5381,9 +5532,9 @@ function createGenerateCommand2() {
 }
 
 // src/commands/linter/validate.ts
-import { Command as Command44 } from "commander";
+import { Command as Command45 } from "commander";
 function createValidateCommand() {
-  return new Command44("validate").description("Validate harness-linter.yml config").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("--json", "Output as JSON").action(async (options) => {
+  return new Command45("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) {
@@ -5402,7 +5553,7 @@ function createValidateCommand() {
 
 // src/commands/linter/index.ts
 function createLinterCommand() {
-  const linter = new Command45("linter").description(
+  const linter = new Command46("linter").description(
     "Generate and validate ESLint rules from YAML config"
   );
   linter.addCommand(createGenerateCommand2());
@@ -5411,7 +5562,7 @@ function createLinterCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command46 } from "commander";
+import { Command as Command47 } from "commander";
 var VALID_TIERS = /* @__PURE__ */ new Set(["core", "standard", "full"]);
 function parseTier(value) {
   const lower = value.toLowerCase();
@@ -5428,7 +5579,7 @@ function parseBudget(value) {
   return n;
 }
 function createMcpCommand() {
-  return new Command46("mcp").description("Start the MCP (Model Context Protocol) server on stdio").option("--tools <tools...>", "Only register the specified tools (used by Cursor integration)").option(
+  return new Command47("mcp").description("Start the MCP (Model Context Protocol) server on stdio").option("--tools <tools...>", "Only register the specified tools (used by Cursor integration)").option(
     "--tier <core|standard|full>",
     "Load a preset tool tier instead of all tools",
     parseTier
@@ -5438,7 +5589,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-MWYIPDQU.js"),
+      import("./mcp-GWVVV6LH.js"),
       import("./tool-tiers-7QGZ3FKY.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -5459,13 +5610,13 @@ function createMcpCommand() {
 }
 
 // src/commands/orchestrator.ts
-import { Command as Command47 } from "commander";
-import * as path39 from "path";
+import { Command as Command48 } from "commander";
+import * as path40 from "path";
 import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command47("orchestrator");
+  const orchestrator = new Command48("orchestrator");
   orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to harness.orchestrator.md", "harness.orchestrator.md").option("--headless", "Run without TUI (server-only mode for use with web dashboard)").action(async (opts) => {
-    const workflowPath = path39.resolve(process.cwd(), opts.workflow);
+    const workflowPath = path40.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -5498,13 +5649,13 @@ function createOrchestratorCommand() {
 
 // src/commands/perf.ts
 init_dist();
-import { Command as Command48 } from "commander";
-import * as path40 from "path";
+import { Command as Command49 } from "commander";
+import * as path41 from "path";
 function registerBenchCommand(perf) {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-ZV6GO6FA.js");
+    const { BenchmarkRunner } = await import("./dist-CJDGASPP.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -5568,7 +5719,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-ZV6GO6FA.js");
+  const { BenchmarkRunner } = await import("./dist-CJDGASPP.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -5609,9 +5760,9 @@ function registerReportCommand(perf) {
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-ZV6GO6FA.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-CJDGASPP.js");
     const analyzer = new EntropyAnalyzer2({
-      rootDir: path40.resolve(cwd),
+      rootDir: path41.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
     const result = await analyzer.analyze();
@@ -5670,7 +5821,7 @@ function registerCriticalPathsCommand(perf) {
   });
 }
 function createPerfCommand() {
-  const perf = new Command48("perf").description("Performance benchmark and baseline management");
+  const perf = new Command49("perf").description("Performance benchmark and baseline management");
   registerBenchCommand(perf);
   registerBaselinesCommands(perf);
   registerReportCommand(perf);
@@ -5679,10 +5830,10 @@ function createPerfCommand() {
 }
 
 // src/commands/persona/index.ts
-import { Command as Command51 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/commands/persona/list.ts
-import { Command as Command49 } from "commander";
+import { Command as Command50 } from "commander";
 function printPersonaList(personas) {
   if (personas.length === 0) {
     logger.info("No personas found.");
@@ -5696,7 +5847,7 @@ function printPersonaList(personas) {
   }
 }
 function createListCommand2() {
-  return new Command49("list").description("List available agent personas").action(async (_opts, cmd) => {
+  return new Command50("list").description("List available agent personas").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
     const result = listPersonas(personasDir);
@@ -5716,17 +5867,17 @@ function createListCommand2() {
 }
 
 // src/commands/persona/generate.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 import * as fs24 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 function generatePersonaArtifacts(persona, outputDir, only) {
   const slug = toKebabCase(persona.name);
   const generated = [];
   if (!only || only === "runtime") {
     const result = generateRuntime(persona);
     if (result.ok) {
-      const outPath = path41.join(outputDir, `${slug}.runtime.json`);
-      fs24.mkdirSync(path41.dirname(outPath), { recursive: true });
+      const outPath = path42.join(outputDir, `${slug}.runtime.json`);
+      fs24.mkdirSync(path42.dirname(outPath), { recursive: true });
       fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
@@ -5734,7 +5885,7 @@ function generatePersonaArtifacts(persona, outputDir, only) {
   if (!only || only === "agents-md") {
     const result = generateAgentsMd(persona);
     if (result.ok) {
-      const outPath = path41.join(outputDir, `${slug}.agents.md`);
+      const outPath = path42.join(outputDir, `${slug}.agents.md`);
       fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
@@ -5742,8 +5893,8 @@ function generatePersonaArtifacts(persona, outputDir, only) {
   if (!only || only === "ci") {
     const result = generateCIWorkflow(persona, "github");
     if (result.ok) {
-      const outPath = path41.join(outputDir, ".github", "workflows", `${slug}.yml`);
-      fs24.mkdirSync(path41.dirname(outPath), { recursive: true });
+      const outPath = path42.join(outputDir, ".github", "workflows", `${slug}.yml`);
+      fs24.mkdirSync(path42.dirname(outPath), { recursive: true });
       fs24.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
@@ -5751,16 +5902,16 @@ function generatePersonaArtifacts(persona, outputDir, only) {
   return generated;
 }
 function createGenerateCommand3() {
-  return new Command50("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
+  return new Command51("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const personaResult = loadPersona(path41.join(resolvePersonasDir(), `${name}.yaml`));
+    const personaResult = loadPersona(path42.join(resolvePersonasDir(), `${name}.yaml`));
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const generated = generatePersonaArtifacts(
       personaResult.value,
-      path41.resolve(opts.outputDir),
+      path42.resolve(opts.outputDir),
       opts.only
     );
     if (!globalOpts.quiet) {
@@ -5773,7 +5924,7 @@ function createGenerateCommand3() {
 
 // src/commands/persona/index.ts
 function createPersonaCommand() {
-  const command = new Command51("persona").description("Agent persona management commands");
+  const command = new Command52("persona").description("Agent persona management commands");
   command.addCommand(createListCommand2());
   command.addCommand(createGenerateCommand3());
   return command;
@@ -5781,8 +5932,8 @@ function createPersonaCommand() {
 
 // src/commands/predict.ts
 init_dist();
-import { Command as Command52 } from "commander";
-import chalk6 from "chalk";
+import { Command as Command53 } from "commander";
+import chalk7 from "chalk";
 var CATEGORY_ORDER = [
   "circular-deps",
   "layer-violations",
@@ -5803,11 +5954,11 @@ function crossingLabel(weeks) {
 function severityPrefix(severity) {
   switch (severity) {
     case "critical":
-      return chalk6.red("[critical]");
+      return chalk7.red("[critical]");
     case "warning":
-      return chalk6.yellow("[warning]");
+      return chalk7.yellow("[warning]");
     case "info":
-      return chalk6.blue("[info]");
+      return chalk7.blue("[info]");
   }
 }
 function printCategoryTable(result) {
@@ -5887,7 +6038,7 @@ function handlePredictError(err, mode) {
   process.exit(ExitCode.ERROR);
 }
 function createPredictCommand() {
-  const command = new Command52("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
+  const command = new Command53("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -5911,8 +6062,8 @@ function createPredictCommand() {
 
 // src/commands/publish-analyses.ts
 import * as fs25 from "fs";
-import * as path42 from "path";
-import { Command as Command53 } from "commander";
+import * as path43 from "path";
+import { Command as Command54 } from "commander";
 init_dist();
 import {
   renderAnalysisComment,
@@ -5920,7 +6071,7 @@ import {
   savePublishedIndex
 } from "@harness-engineering/orchestrator";
 function bootstrapTrackerCommand(opts, verb) {
-  const projectPath = path42.resolve(opts.dir);
+  const projectPath = path43.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -5932,7 +6083,7 @@ function bootstrapTrackerCommand(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path42.join(projectPath, ".env");
+  const projectEnvPath = path43.join(projectPath, ".env");
   if (fs25.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
@@ -5944,7 +6095,7 @@ function bootstrapTrackerCommand(opts, verb) {
   return { token, projectPath, trackerConfig };
 }
 function buildNameToExternalIdMap(projectPath) {
-  const roadmapFile = path42.join(projectPath, "docs", "roadmap.md");
+  const roadmapFile = path43.join(projectPath, "docs", "roadmap.md");
   if (!fs25.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot map issue hashes to external IDs.");
     return null;
@@ -6000,8 +6151,8 @@ async function runPublishAnalyses(opts) {
   const nameToExternalId = buildNameToExternalIdMap(projectPath);
   if (!nameToExternalId) return process.exit(1);
   const { AnalysisArchive } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-ZV6GO6FA.js");
-  const archive = new AnalysisArchive(path42.join(projectPath, ".harness", "analyses"));
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-CJDGASPP.js");
+  const archive = new AnalysisArchive(path43.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
     logger.info("No analyses found to publish.");
@@ -6023,7 +6174,7 @@ async function runPublishAnalyses(opts) {
   }
 }
 function createPublishAnalysesCommand() {
-  const command = new Command53("publish-analyses").description(
+  const command = new Command54("publish-analyses").description(
     "Publishes locally generated intelligence analyses to the external issue tracker (e.g., GitHub)"
   ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
     try {
@@ -6039,8 +6190,8 @@ function createPublishAnalysesCommand() {
 }
 
 // src/commands/recommend.ts
-import { Command as Command54 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command55 } from "commander";
+import chalk8 from "chalk";
 async function resolveSnapshot(cwd, noCache) {
   if (!noCache) {
     const cached = loadCachedSnapshot(cwd);
@@ -6074,12 +6225,12 @@ async function runRecommend(options) {
 function formatRecommendation(rec) {
   const lines = [];
   if (rec.urgency === "critical") {
-    lines.push(`  ${chalk7.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
+    lines.push(`  ${chalk8.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
   } else {
     lines.push(`  ${rec.sequence}. ${rec.skillName} (${rec.score.toFixed(2)})`);
   }
   for (const reason of rec.reasons) {
-    lines.push(`     ${chalk7.dim("\u2192")} ${reason}`);
+    lines.push(`     ${chalk8.dim("\u2192")} ${reason}`);
   }
   return lines.join("\n");
 }
@@ -6103,7 +6254,7 @@ function printRecommendations(result) {
   console.log("");
 }
 function createRecommendCommand() {
-  const command = new Command54("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
+  const command = new Command55("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -6140,9 +6291,9 @@ function createRecommendCommand() {
 
 // src/commands/scan-config.ts
 init_dist();
-import { Command as Command55 } from "commander";
+import { Command as Command56 } from "commander";
 import { existsSync as existsSync22, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
-import { join as join30, relative as relative2 } from "path";
+import { join as join31, relative as relative2 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -6199,7 +6350,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join30(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join31(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -6229,7 +6380,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command55("scan-config").description(
+  const command = new Command56("scan-config").description(
     "Scan CLAUDE.md, AGENTS.md, .gemini/settings.json, and skill.yaml for prompt injection patterns"
   ).option("--path <dir>", "Target directory to scan (default: cwd)").option("--fix", "Strip high-severity patterns from files in-place").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -6246,18 +6397,18 @@ function createScanConfigCommand() {
 }
 
 // src/commands/setup.ts
-import { Command as Command56 } from "commander";
+import { Command as Command57 } from "commander";
 import * as fs28 from "fs";
 import * as os7 from "os";
-import * as path45 from "path";
-import chalk9 from "chalk";
+import * as path46 from "path";
+import chalk10 from "chalk";
 
 // src/utils/first-run.ts
 import * as fs26 from "fs";
 import * as os6 from "os";
-import * as path43 from "path";
-var HARNESS_DIR = path43.join(os6.homedir(), ".harness");
-var MARKER_FILE = path43.join(HARNESS_DIR, ".setup-complete");
+import * as path44 from "path";
+var HARNESS_DIR = path44.join(os6.homedir(), ".harness");
+var MARKER_FILE = path44.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
   return !fs26.existsSync(MARKER_FILE);
 }
@@ -6277,9 +6428,9 @@ function printFirstRunWelcome() {
 
 // src/commands/telemetry-wizard.ts
 import * as fs27 from "fs";
-import * as path44 from "path";
+import * as path45 from "path";
 import readline from "readline";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -6308,7 +6459,7 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path44.join(cwd, "harness.config.json");
+  const configPath = path45.join(cwd, "harness.config.json");
   try {
     const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
@@ -6317,7 +6468,7 @@ function isTelemetryConfigured(cwd) {
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path44.join(cwd, "harness.config.json");
+  const configPath = path45.join(cwd, "harness.config.json");
   try {
     const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
@@ -6330,15 +6481,15 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path44.join(cwd, ".harness");
+    const harnessDir = path45.join(cwd, ".harness");
     fs27.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path44.join(harnessDir, "telemetry.json");
+    const telemetryFile = path45.join(harnessDir, "telemetry.json");
     fs27.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
   }
 }
 async function promptIdentity() {
   console.log(
-    `  ${chalk8.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
+    `  ${chalk9.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
   );
   console.log("  Leave blank to keep anonymous.");
   const answer = await prompt("  Set identity fields? (y/N) ");
@@ -6356,20 +6507,20 @@ async function promptIdentity() {
 async function runTelemetryWizard() {
   if (!process.stdin.isTTY) return null;
   console.log("");
-  console.log(`  ${chalk8.bold("Telemetry Configuration")}`);
+  console.log(`  ${chalk9.bold("Telemetry Configuration")}`);
   console.log("");
   console.log("  Harness can collect anonymous usage data to help improve the tool.");
   console.log("  You can change these settings anytime in harness.config.json.");
   console.log("");
   console.log(
-    `  ${chalk8.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
+    `  ${chalk9.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
   );
   console.log("  No code, file contents, or personally identifiable info is sent.");
   const telemetryAnswer = await prompt("  Enable anonymous telemetry? (Y/n) ");
   const telemetryEnabled = !isNo(telemetryAnswer);
   console.log("");
   console.log(
-    `  ${chalk8.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
+    `  ${chalk9.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
   );
   console.log("  Stored locally in .harness/adoption/. Never sent externally.");
   const adoptionAnswer = await prompt("  Enable local adoption tracking? (Y/n) ");
@@ -6379,7 +6530,7 @@ async function runTelemetryWizard() {
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path44.join(cwd, "harness.config.json");
+  const configPath = path45.join(cwd, "harness.config.json");
   if (!fs27.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
@@ -6426,7 +6577,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs28.existsSync(path45.join(os7.homedir(), dirName));
+  return fs28.existsSync(path46.join(os7.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -6463,12 +6614,12 @@ async function runMcpSetup(cwd) {
   return results;
 }
 function formatStep(result) {
-  const icon = result.status === "pass" ? chalk9.green("\u2713") : result.status === "warn" ? chalk9.yellow("\u26A0") : chalk9.red("\u2717");
+  const icon = result.status === "pass" ? chalk10.green("\u2713") : result.status === "warn" ? chalk10.yellow("\u26A0") : chalk10.red("\u2717");
   return `  ${icon} ${result.message}`;
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path45.join(cwd, ".mcp.json");
+    const mcpPath = path46.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -6477,9 +6628,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path45.join(cwd, ".gemini");
+    const geminiDir = path46.join(cwd, ".gemini");
     if (fs28.existsSync(geminiDir)) {
-      const geminiPath = path45.join(geminiDir, "settings.json");
+      const geminiPath = path46.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -6500,12 +6651,12 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path45.join(cwd, "harness.config.json");
+  const configPath = path46.join(cwd, "harness.config.json");
   if (!fs28.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path45.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path46.join(cwd, ".harness", "hooks", "profile.json");
   try {
     const data = JSON.parse(fs28.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
@@ -6526,7 +6677,7 @@ function ensureHooks(cwd) {
 }
 async function runInitialGraphScan(cwd) {
   try {
-    const { runScan: runScan2 } = await import("./scan-BGJ7TLLV.js");
+    const { runScan: runScan2 } = await import("./scan-WM7XDUF7.js");
     const result = await runScan2(cwd);
     return {
       status: "pass",
@@ -6563,10 +6714,10 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command56("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command57("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
-    console.log(`  ${chalk9.bold("harness setup")}`);
+    console.log(`  ${chalk10.bold("harness setup")}`);
     console.log("");
     const { steps, success } = await runSetup(cwd);
     for (const step of steps) {
@@ -6586,14 +6737,14 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist();
-import { Command as Command57 } from "commander";
+import { Command as Command58 } from "commander";
 import * as fs29 from "fs";
-import * as path46 from "path";
+import * as path47 from "path";
 import { parse as parseYaml } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path46.resolve(projectPath);
-  const manifestPath = path46.join(rootDir, MANIFEST_FILENAME);
+  const rootDir = path47.resolve(projectPath);
+  const manifestPath = path47.join(rootDir, MANIFEST_FILENAME);
   if (!fs29.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
@@ -6617,7 +6768,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path46.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path47.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -6635,8 +6786,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path46.resolve(options.output);
-  const outputPath = path46.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path47.resolve(options.output);
+  const outputPath = path47.join(outputDir, `${manifest.name}.harness-constraints.json`);
   const writeResult = await writeConfig(outputPath, bundle);
   if (!writeResult.ok) {
     logger.error(`Failed to write bundle: ${writeResult.error.message}`);
@@ -6645,25 +6796,25 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command57("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
+  return new Command58("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
     await runShareAction(projectPath, options);
   });
 }
 
 // src/commands/skill/index.ts
-import { Command as Command65 } from "commander";
+import { Command as Command66 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command58 } from "commander";
+import { Command as Command59 } from "commander";
 import * as fs30 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
   if (!fs30.existsSync(dirPath)) return [];
   const entries = fs30.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path47.join(dirPath, name, "skill.yaml");
+    const yamlPath = path48.join(dirPath, name, "skill.yaml");
     if (!fs30.existsSync(yamlPath)) continue;
     try {
       const raw = fs30.readFileSync(yamlPath, "utf-8");
@@ -6684,10 +6835,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path47.dirname(globalDir);
-  const communityBase = path47.join(skillsDir, "community");
-  const communityPlatformDir = path47.join(communityBase, "claude-code");
-  const lockfilePath = path47.join(communityBase, "skills-lock.json");
+  const skillsDir = path48.dirname(globalDir);
+  const communityBase = path48.join(skillsDir, "community");
+  const communityPlatformDir = path48.join(communityBase, "claude-code");
+  const lockfilePath = path48.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -6757,7 +6908,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command58("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
+  return new Command59("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skills = collectSkills({ filter: resolveFilter(opts) });
     if (globalOpts.json) {
@@ -6772,9 +6923,9 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command59 } from "commander";
+import { Command as Command60 } from "commander";
 import * as fs31 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -6870,7 +7021,7 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path48.join(skillDir, "skill.yaml");
+  const yamlPath = path49.join(skillDir, "skill.yaml");
   if (!fs31.existsSync(yamlPath)) return null;
   try {
     const result = SkillMetadataSchema.safeParse(parse2(fs31.readFileSync(yamlPath, "utf-8")));
@@ -6885,18 +7036,18 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path48.join(projectPath, "docs", "principles.md");
+  const principlesPath = path49.join(projectPath, "docs", "principles.md");
   return fs31.existsSync(principlesPath) ? fs31.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs31.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs31.statSync(path48.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs31.readFileSync(path48.join(dirPath, files[0].name), "utf-8");
+  const files = fs31.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs31.statSync(path49.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs31.readFileSync(path49.join(dirPath, files[0].name), "utf-8");
   return void 0;
 }
 function loadPriorState(metadata, projectPath) {
   if (!metadata?.state.persistent || metadata.state.files.length === 0) return void 0;
   for (const stateFilePath of metadata.state.files) {
-    const fullPath = path48.join(projectPath, stateFilePath);
+    const fullPath = path49.join(projectPath, stateFilePath);
     if (!fs31.existsSync(fullPath)) continue;
     const stat = fs31.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
@@ -6920,7 +7071,7 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const stateFile = path48.join(projectPath, ".harness", "state.json");
+  const stateFile = path49.join(projectPath, ".harness", "state.json");
   if (!fs31.existsSync(stateFile)) return content;
   const stateContent = fs31.readFileSync(stateFile, "utf-8");
   return content + `
@@ -6934,14 +7085,14 @@ ${stateContent}
 }
 async function runSkill(name, opts) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path48.join(skillsDir, name);
+  const skillDir = path49.join(skillsDir, name);
   if (!fs31.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path48.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path49.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -6968,7 +7119,7 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path48.join(skillDir, "SKILL.md");
+  const skillMdPath = path49.join(skillDir, "SKILL.md");
   if (!fs31.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
@@ -6984,13 +7135,13 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand2() {
-  return new Command59("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Rigor level: fast, standard, thorough", "standard").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts) => runSkill(name, opts));
+  return new Command60("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Rigor level: fast, standard, thorough", "standard").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts) => runSkill(name, opts));
 }
 
 // src/commands/skill/validate.ts
-import { Command as Command60 } from "commander";
+import { Command as Command61 } from "commander";
 import * as fs32 from "fs";
-import * as path49 from "path";
+import * as path50 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -7031,8 +7182,8 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path49.join(skillsDir, name);
-  const yamlPath = path49.join(skillDir, "skill.yaml");
+  const skillDir = path50.join(skillsDir, name);
+  const yamlPath = path50.join(skillDir, "skill.yaml");
   if (!fs32.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
@@ -7044,7 +7195,7 @@ function validateSkillEntry(name, skillsDir, errors) {
       errors.push(`${name}/skill.yaml: ${result.error.message}`);
       return false;
     }
-    validateSkillMd(name, path49.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path50.join(skillDir, "SKILL.md"), result.data.type, errors);
     return true;
   } catch (e) {
     errors.push(`${name}: parse error \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -7052,7 +7203,7 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command60("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command61("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
     if (!fs32.existsSync(skillsDir)) {
@@ -7082,18 +7233,18 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command61 } from "commander";
+import { Command as Command62 } from "commander";
 import * as fs33 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path50.join(skillsDir, name);
+  const skillDir = path51.join(skillsDir, name);
   if (!fs33.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path50.join(skillDir, "skill.yaml");
+  const yamlPath = path51.join(skillDir, "skill.yaml");
   if (!fs33.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
@@ -7128,7 +7279,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command61("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command62("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const loaded = loadSkillMetadata2(name);
     if (!loaded.ok) {
@@ -7145,7 +7296,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command62 } from "commander";
+import { Command as Command63 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -7190,14 +7341,14 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand() {
-  return new Command62("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
+  return new Command63("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
     await runSearchAction(query, opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/skill/create.ts
-import { Command as Command63 } from "commander";
-import * as path51 from "path";
+import { Command as Command64 } from "commander";
+import * as path52 from "path";
 import * as fs34 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
@@ -7282,21 +7433,21 @@ function runCreate(name, opts) {
   if (!KEBAB_CASE_RE.test(name)) {
     throw new Error(`Invalid skill name "${name}". Must be kebab-case (e.g., my-skill).`);
   }
-  const baseDir = opts.outputDir ?? path51.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path51.join(baseDir, name);
+  const baseDir = opts.outputDir ?? path52.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path52.join(baseDir, name);
   if (fs34.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
   fs34.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path51.join(skillDir, "skill.yaml");
+  const skillYamlPath = path52.join(skillDir, "skill.yaml");
   fs34.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path51.join(skillDir, "SKILL.md");
+  const skillMdPath = path52.join(skillDir, "SKILL.md");
   fs34.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path51.join(skillDir, "README.md");
+  const readmePath = path52.join(skillDir, "README.md");
   fs34.writeFileSync(readmePath, readme);
   return {
     name,
@@ -7311,12 +7462,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path51.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path52.join(result.directory, "SKILL.md")} with your skill content`);
   logger.info(`  2. Run: harness skill validate ${name}`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  return new Command63("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
+  return new Command64("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = runCreate(name, {
@@ -7339,19 +7490,19 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command64 } from "commander";
+import { Command as Command65 } from "commander";
 import * as fs36 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 
 // src/registry/validator.ts
 import * as fs35 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path52.join(skillDir, "skill.yaml");
+  const skillYamlPath = path53.join(skillDir, "skill.yaml");
   if (!fs35.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
@@ -7380,7 +7531,7 @@ async function validateForPublish(skillDir, registryUrl) {
   if (!skillMeta.triggers || skillMeta.triggers.length === 0) {
     errors.push("At least one trigger is required. Add triggers to skill.yaml.");
   }
-  const skillMdPath = path52.join(skillDir, "SKILL.md");
+  const skillMdPath = path53.join(skillDir, "SKILL.md");
   if (!fs35.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
@@ -7464,11 +7615,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path53.join(skillDir, "package.json");
+  const pkgPath = path54.join(skillDir, "package.json");
   fs36.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path53.join(skillDir, "README.md");
+  const readmePath = path54.join(skillDir, "README.md");
   if (!fs36.existsSync(readmePath)) {
-    const skillMdContent = fs36.readFileSync(path53.join(skillDir, "SKILL.md"), "utf-8");
+    const skillMdContent = fs36.readFileSync(path54.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -7508,7 +7659,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command64("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
+  return new Command65("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillDir = opts.dir || process.cwd();
     try {
@@ -7533,7 +7684,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command65("skill").description("Skill management commands");
+  const command = new Command66("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand2());
   command.addCommand(createValidateCommand2());
@@ -7546,9 +7697,9 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist();
-import { Command as Command66 } from "commander";
+import { Command as Command67 } from "commander";
 import { execSync as execSync5 } from "child_process";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function getCommitHash3(cwd) {
   try {
     return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
@@ -7573,9 +7724,9 @@ function formatDelta(delta) {
 function directionSymbol(direction) {
   switch (direction) {
     case "improving":
-      return chalk10.green("improving");
+      return chalk11.green("improving");
     case "declining":
-      return chalk10.red("declining");
+      return chalk11.red("declining");
     case "stable":
       return "=";
   }
@@ -7728,7 +7879,7 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command66("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command67("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand(command);
@@ -7736,12 +7887,12 @@ function createSnapshotCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command71 } from "commander";
+import { Command as Command72 } from "commander";
 
 // src/commands/state/show.ts
 init_dist();
-import { Command as Command67 } from "commander";
-import * as path54 from "path";
+import { Command as Command68 } from "commander";
+import * as path55 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -7765,9 +7916,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command67("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
+  return new Command68("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const result = await loadState(path54.resolve(opts.path), opts.stream);
+    const result = await loadState(path55.resolve(opts.path), opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -7783,9 +7934,9 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist();
-import { Command as Command68 } from "commander";
+import { Command as Command69 } from "commander";
 import * as fs37 from "fs";
-import * as path55 from "path";
+import * as path56 from "path";
 import * as readline2 from "readline";
 async function resolveStatePath(projectPath, stream) {
   if (stream) {
@@ -7794,9 +7945,9 @@ async function resolveStatePath(projectPath, stream) {
       logger.error(streamResult.error.message);
       process.exit(ExitCode.ERROR);
     }
-    return path55.join(streamResult.value, "state.json");
+    return path56.join(streamResult.value, "state.json");
   }
-  return path55.join(projectPath, ".harness", "state.json");
+  return path56.join(projectPath, ".harness", "state.json");
 }
 async function confirmReset() {
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -7807,7 +7958,7 @@ async function confirmReset() {
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path55.resolve(opts.path);
+  const projectPath = path56.resolve(opts.path);
   const statePath = await resolveStatePath(projectPath, opts.stream);
   if (!fs37.existsSync(statePath)) {
     logger.info("No state file found. Nothing to reset.");
@@ -7827,16 +7978,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command68("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
+  return new Command69("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
 }
 
 // src/commands/state/learn.ts
 init_dist();
-import { Command as Command69 } from "commander";
-import * as path56 from "path";
+import { Command as Command70 } from "commander";
+import * as path57 from "path";
 function createLearnCommand() {
-  return new Command69("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
-    const projectPath = path56.resolve(opts.path);
+  return new Command70("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 = path57.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -7850,10 +8001,10 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist();
-import { Command as Command70 } from "commander";
-import * as path57 from "path";
+import { Command as Command71 } from "commander";
+import * as path58 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path57.resolve(opts.path);
+  const projectPath = path58.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -7874,7 +8025,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path57.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path58.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7883,7 +8034,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path57.resolve(opts.path), name);
+  const result = await archiveStream(path58.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7892,7 +8043,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path57.resolve(opts.path), name);
+  const result = await setActiveStream(path58.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -7901,7 +8052,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command70("streams").description("Manage state streams");
+  const command = new Command71("streams").description("Manage state streams");
   command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => runListStreams(opts, cmd.optsWithGlobals()));
   command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => runCreateStream(name, opts));
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => runArchiveStream(name, opts));
@@ -7911,7 +8062,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command71("state").description("Project state management commands");
+  const command = new Command72("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -7921,8 +8072,8 @@ function createStateCommand() {
 
 // src/commands/sync-analyses.ts
 import * as fs38 from "fs";
-import * as path58 from "path";
-import { Command as Command72 } from "commander";
+import * as path59 from "path";
+import { Command as Command73 } from "commander";
 init_dist();
 function isValidRecord(record) {
   return typeof record.issueId === "string" && !!record.issueId && typeof record.identifier === "string" && !!record.identifier && typeof record.analyzedAt === "string" && !/[/\\]/.test(record.issueId);
@@ -7948,7 +8099,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path58.resolve(opts.dir);
+  const projectPath = path59.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -7960,7 +8111,7 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path58.join(projectPath, ".env");
+  const projectEnvPath = path59.join(projectPath, ".env");
   if (fs38.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
@@ -7972,7 +8123,7 @@ function bootstrapTrackerCommand2(opts, verb) {
   return { token, projectPath, trackerConfig };
 }
 function loadRoadmapFeatures(projectPath) {
-  const roadmapFile = path58.join(projectPath, "docs", "roadmap.md");
+  const roadmapFile = path59.join(projectPath, "docs", "roadmap.md");
   if (!fs38.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot discover features with externalIds.");
     return null;
@@ -8029,9 +8180,9 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-ZV6GO6FA.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-CJDGASPP.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path58.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path59.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -8051,7 +8202,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command72("sync-analyses").description(
+  const command = new Command73("sync-analyses").description(
     "Pull published intelligence analyses from the external issue tracker into the local .harness/analyses/ directory"
   ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
     try {
@@ -8066,7 +8217,7 @@ function createSyncAnalysesCommand() {
 
 // src/commands/taint.ts
 init_dist();
-import { Command as Command73 } from "commander";
+import { Command as Command74 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -8138,26 +8289,26 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command73("taint").description("Manage sentinel session taint state");
+  const taint = new Command74("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command77 } from "commander";
+import { Command as Command78 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist();
-import { Command as Command74 } from "commander";
+import { Command as Command75 } from "commander";
 import * as fs39 from "fs";
-import * as path59 from "path";
+import * as path60 from "path";
 function telemetryFilePath(cwd) {
-  return path59.join(cwd, ".harness", "telemetry.json");
+  return path60.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path59.dirname(filePath);
+  const dir = path60.dirname(filePath);
   fs39.mkdirSync(dir, { recursive: true });
   fs39.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
@@ -8173,7 +8324,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command74("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
+  const cmd = new Command75("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
     const cwd = process.cwd();
     if (opts.clear) {
       writeTelemetryFile(cwd, { identity: {} });
@@ -8198,7 +8349,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist();
-import { Command as Command75 } from "commander";
+import { Command as Command76 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -8240,7 +8391,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 function createStatusCommand() {
-  const cmd = new Command75("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command76("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
     const cwd = process.cwd();
     const envOverrides = gatherEnvOverrides();
     const consent = resolveConsent(cwd, void 0);
@@ -8273,11 +8424,11 @@ function createStatusCommand() {
 
 // src/commands/telemetry/test.ts
 init_dist();
-import { Command as Command76 } from "commander";
+import { Command as Command77 } from "commander";
 
 // src/bin/command-telemetry.ts
 import { existsSync as existsSync36, readFileSync as readFileSync25, mkdirSync as mkdirSync15, appendFileSync, writeFileSync as writeFileSync18 } from "fs";
-import { join as join45, parse as parsePath, resolve as resolve33 } from "path";
+import { join as join46, parse as parsePath, resolve as resolve33 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
@@ -8285,7 +8436,7 @@ function findProjectRoot(cwd) {
   let dir = resolve33(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync36(join45(dir, "harness.config.json"))) return dir;
+    if (existsSync36(join46(dir, "harness.config.json"))) return dir;
     dir = resolve33(dir, "..");
   }
   return cwd;
@@ -8323,7 +8474,7 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join45(cwd, ".harness", "metrics");
+    const metricsDir = join46(cwd, ".harness", "metrics");
     mkdirSync15(metricsDir, { recursive: true });
     const record = {
       skill: command,
@@ -8333,13 +8484,13 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join45(metricsDir, "adoption.jsonl");
+    const adoptionFile = join46(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join45(cwd, "harness.config.json");
+  const configPath = join46(cwd, "harness.config.json");
   if (!existsSync36(configPath)) return false;
   try {
     const config = JSON.parse(readFileSync25(configPath, "utf-8"));
@@ -8354,10 +8505,10 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join45(cwd, ".harness", "metrics", "adoption.jsonl");
+    const adoptionFile = join46(cwd, ".harness", "metrics", "adoption.jsonl");
     if (!existsSync36(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join45(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    const reporterPath = join46(cwd, ".harness", "hooks", "telemetry-reporter.js");
     if (!existsSync36(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
@@ -8395,7 +8546,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command76("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command77("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
     const cwd = process.cwd();
     const consent = resolveConsent(cwd, void 0);
     if (!consent.allowed) {
@@ -8432,7 +8583,7 @@ function createTestCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command77("telemetry").description("Telemetry identity and status management");
+  const command = new Command78("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   command.addCommand(createTestCommand());
@@ -8440,8 +8591,8 @@ function createTelemetryCommand() {
 }
 
 // src/commands/traceability.ts
-import { Command as Command78 } from "commander";
-import chalk11 from "chalk";
+import { Command as Command79 } from "commander";
+import chalk12 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
   if (maxConfidence > 0) return "inferred";
@@ -8450,13 +8601,13 @@ function confidenceLabel(maxConfidence) {
 function statusIcon(status) {
   switch (status) {
     case "full":
-      return chalk11.green("\u2713 full");
+      return chalk12.green("\u2713 full");
     case "code-only":
-      return chalk11.yellow("\u25D0 code-only");
+      return chalk12.yellow("\u25D0 code-only");
     case "test-only":
-      return chalk11.yellow("\u25D0 test-only");
+      return chalk12.yellow("\u25D0 test-only");
     case "none":
-      return chalk11.red("\u2717 none");
+      return chalk12.red("\u2717 none");
     default:
       return status;
   }
@@ -8498,14 +8649,14 @@ function handleEmptyResults(mode) {
 }
 function printResultTable(result, mode) {
   const specLabel = result.specPath || result.featureName || "Unknown";
-  console.log(`  ${chalk11.cyan(specLabel)} ${chalk11.dim(`(${result.summary.total} requirements)`)}`);
+  console.log(`  ${chalk12.cyan(specLabel)} ${chalk12.dim(`(${result.summary.total} requirements)`)}`);
   console.log("");
   const numWidth = 4;
   const nameWidth = mode === OutputMode.VERBOSE ? 44 : 36;
   const codeWidth = 6;
   const testWidth = 7;
   const confWidth = 12;
-  const header = chalk11.dim(
+  const header = chalk12.dim(
     `  ${pad("#", numWidth)}${pad("Requirement", nameWidth)}${pad("Code", codeWidth)}${pad("Tests", testWidth)}${pad("Confidence", confWidth)}Status`
   );
   console.log(header);
@@ -8534,10 +8685,10 @@ function printRequirementRows(requirements, mode, cols) {
     );
     if (mode === OutputMode.VERBOSE) {
       for (const f of req.codeFiles) {
-        console.log(chalk11.dim(`        code: ${f.path} (${f.method})`));
+        console.log(chalk12.dim(`        code: ${f.path} (${f.method})`));
       }
       for (const f of req.testFiles) {
-        console.log(chalk11.dim(`        test: ${f.path} (${f.method})`));
+        console.log(chalk12.dim(`        test: ${f.path} (${f.method})`));
       }
     }
   }
@@ -8548,7 +8699,7 @@ function printCoverageSummary(summary) {
   const codePct = s.total > 0 ? Math.round(s.withCode / s.total * 100) : 0;
   const testPct = s.total > 0 ? Math.round(s.withTests / s.total * 100) : 0;
   console.log(
-    `  ${chalk11.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
+    `  ${chalk12.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
   );
 }
 async function runTraceability(options) {
@@ -8556,7 +8707,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore(mode);
-  const graphModule = await import("./dist-HPWNWCT6.js");
+  const graphModule = await import("./dist-NCNAXUFD.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -8564,14 +8715,14 @@ async function runTraceability(options) {
     console.log(JSON.stringify(results, null, 2));
   } else {
     console.log("");
-    console.log(chalk11.bold("Spec-to-Implementation Traceability"));
+    console.log(chalk12.bold("Spec-to-Implementation Traceability"));
     console.log("");
     for (const result of results) printResultTable(result, mode);
   }
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command78("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
+  return new Command79("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     await runTraceability({
       spec: opts.spec,
@@ -8584,15 +8735,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path60 from "path";
-import { Command as Command79 } from "commander";
+import * as path61 from "path";
+import { Command as Command80 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path60.dirname(globalDir);
-  const communityBase = path60.join(skillsDir, "community");
-  const lockfilePath = path60.join(communityBase, "skills-lock.json");
+  const skillsDir = path61.dirname(globalDir);
+  const communityBase = path61.join(skillsDir, "community");
+  const lockfilePath = path61.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -8622,7 +8773,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command79("uninstall");
+  const cmd = new Command80("uninstall");
   cmd.description("Uninstall a community skill").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--force", "Remove even if other skills depend on this one").action(async (skill, opts) => {
     try {
       const result = await runUninstall(skill, opts);
@@ -8643,8 +8794,8 @@ function createUninstallCommand() {
 // src/commands/uninstall-constraints.ts
 init_dist();
 import * as fs40 from "fs/promises";
-import * as path61 from "path";
-import { Command as Command80 } from "commander";
+import * as path62 from "path";
+import { Command as Command81 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -8701,11 +8852,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command80("uninstall-constraints");
+  const cmd = new Command81("uninstall-constraints");
   cmd.description("Remove a previously installed constraints package").argument("<name>", "Name of the constraint package to uninstall").option("-c, --config <path>", "Path to harness.config.json").action(async (name, opts) => {
     let configPath;
     if (opts.config) {
-      configPath = path61.resolve(opts.config);
+      configPath = path62.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -8714,8 +8865,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path61.dirname(configPath);
-    const lockfilePath = path61.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path62.dirname(configPath);
+    const lockfilePath = path62.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -8740,13 +8891,13 @@ function createUninstallConstraintsCommand() {
 }
 
 // src/commands/update.ts
-import { Command as Command81 } from "commander";
+import { Command as Command82 } from "commander";
 import { execFile, execFileSync as execFileSync6 } from "child_process";
 import { realpathSync, existsSync as existsSync37, readFileSync as readFileSync26 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 import { promisify } from "util";
 import readline3 from "readline";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -8827,10 +8978,10 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join48(cwd, "harness.config.json");
+  const configPath = join49(cwd, "harness.config.json");
   if (!existsSync37(configPath)) return;
   let profile = "standard";
-  const profilePath = join48(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join49(cwd, ".harness", "hooks", "profile.json");
   try {
     const data = JSON.parse(readFileSync26(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
@@ -8852,7 +9003,7 @@ function runLocalGraphScan() {
     execFileSync6("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
-    console.log(`  ${chalk12.cyan("harness graph scan .")}`);
+    console.log(`  ${chalk13.cyan("harness graph scan .")}`);
   }
 }
 async function offerRegeneration() {
@@ -8869,7 +9020,7 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk12.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk13.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
   if (!isGlobal) {
     runLocalGraphScan();
@@ -8932,8 +9083,8 @@ async function runUpdateAction(opts, globalOpts) {
     console.log("");
     for (const { pkg, current, latest } of outdated) {
       const shortName = pkg.replace("@harness-engineering/", "");
-      const currentStr = current ? chalk12.dim(`v${current}`) : chalk12.dim("not installed");
-      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk12.green(`v${latest}`)}`);
+      const currentStr = current ? chalk13.dim(`v${current}`) : chalk13.dim("not installed");
+      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk13.green(`v${latest}`)}`);
     }
     console.log("");
   }
@@ -8949,7 +9100,7 @@ async function runUpdateAction(opts, globalOpts) {
   } catch {
     console.log("");
     logger.error("Update failed. You can try manually:");
-    console.log(`  ${chalk12.cyan(installCmd)}`);
+    console.log(`  ${chalk13.cyan(installCmd)}`);
     process.exit(ExitCode.ERROR);
   }
   refreshHooks();
@@ -8958,7 +9109,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command81("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
+  return new Command82("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
     "--regenerate",
     "Only regenerate slash commands and agent definitions (skip package updates)"
   ).action(async (opts, cmd) => {
@@ -8968,9 +9119,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command82 } from "commander";
+import { Command as Command83 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-ZV6GO6FA.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-CJDGASPP.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -9063,7 +9214,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-ZV6GO6FA.js");
+    const { aggregateByDay } = await import("./dist-CJDGASPP.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -9092,7 +9243,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-ZV6GO6FA.js");
+    const { aggregateBySession } = await import("./dist-CJDGASPP.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -9172,7 +9323,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-ZV6GO6FA.js");
+    const { aggregateBySession } = await import("./dist-CJDGASPP.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -9207,7 +9358,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-ZV6GO6FA.js");
+    const { aggregateBySession } = await import("./dist-CJDGASPP.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -9233,7 +9384,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command82("usage").description("Token usage and cost tracking");
+  const usage = new Command83("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -9248,15 +9399,15 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist();
 init_dist();
-import { Command as Command83 } from "commander";
-import * as path62 from "path";
+import { Command as Command84 } from "commander";
+import * as path63 from "path";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path62.dirname(path62.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path63.dirname(path63.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -9266,7 +9417,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path62.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path63.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -9331,11 +9482,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-GQX7OVCR.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-BKCNLZYG.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path62.join(cwd, "docs", "specs"),
-    plansDir: path62.join(cwd, "docs", "plans"),
+    specsDir: path63.join(cwd, "docs", "specs"),
+    plansDir: path63.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -9347,7 +9498,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command83("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command84("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
     "--agent-configs",
     "Validate agent configs (CLAUDE.md, hooks, skills) via agnix or built-in fallback rules"
   ).option("--strict", "Treat warnings as errors (applies to --agent-configs)").option("--agnix-bin <path>", "Override the agnix binary path discovered on PATH").action(async (opts, cmd) => runValidateAction(opts, cmd.optsWithGlobals()));
@@ -9397,6 +9548,7 @@ Agent configs checked via ${engineLabel}${note}`);
 // src/commands/_registry.ts
 var commandCreators = [
   createAddCommand,
+  createAdviseSkillsCommand,
   createAdoptionCommand,
   createAgentCommand,
   createAuditProtectedCommand,
@@ -9425,6 +9577,7 @@ var commandCreators = [
   createInstallCommand,
   createInstallConstraintsCommand,
   createIntegrationsCommand,
+  createKnowledgePipelineCommand,
   createLearningsCommand,
   createLinterCommand,
   createMcpCommand,
@@ -9456,7 +9609,7 @@ var commandCreators = [
 
 // src/index.ts
 function createProgram() {
-  const program = new Command84();
+  const program = new Command85();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   for (const creator of commandCreators) {
     program.addCommand(creator());