@harness-engineering/cli 1.10.0 → 1.12.0

package/dist/{chunk-PAHHT2IK.js → chunk-B5SBNH4S.js}

@@ -5,13 +5,14 @@ import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand,
+  findConfigFile,
   findFiles,
   resolveConfig
-} from "./chunk-7X7ZAYMY.js";
+} from "./chunk-ZU2UBYBY.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-46YA6FI3.js";
+} from "./chunk-GNGELAXY.js";
 import {
   listPersonas,
   loadPersona
@@ -21,16 +22,16 @@ import {
 } from "./chunk-TRAPF4IX.js";
 import {
   executeSkill
-} from "./chunk-F3YDAJFQ.js";
+} from "./chunk-L2KLU56K.js";
 import {
   ALLOWED_PERSONA_COMMANDS
 } from "./chunk-TEFCFC4H.js";
 import {
   createCreateSkillCommand
-} from "./chunk-ECUJQS3B.js";
+} from "./chunk-6N4R6FVX.js";
 import {
   logger
-} from "./chunk-HIOXKZYF.js";
+} from "./chunk-EBJQ6N4M.js";
 import {
   generate,
   validate
@@ -47,24 +48,27 @@ import {
 import {
   createGenerateSlashCommandsCommand,
   generateSlashCommands,
+  handleGetImpact,
   handleOrphanDeletion
-} from "./chunk-LXU5M77O.js";
+} from "./chunk-747VBPA4.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-ZOAWBDWU.js";
 import {
+  resolveGlobalSkillsDir,
   resolvePersonasDir,
+  resolveProjectSkillsDir,
   resolveSkillsDir,
   resolveTemplatesDir
-} from "./chunk-EOLRW32Q.js";
+} from "./chunk-HD4IBGLA.js";
 import {
   CLIError,
   ExitCode,
   handleError
-} from "./chunk-B7HFEHWP.js";
+} from "./chunk-3WGJMBKH.js";
 import {
   SkillMetadataSchema
-} from "./chunk-MDUK2J2O.js";
+} from "./chunk-VRFZWGMS.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -72,11 +76,17 @@ import {
   TemplateEngine
 } from "./chunk-C2ERUR3L.js";
 import {
+  ArchBaselineManager,
+  ArchConfigSchema,
   BaselineManager,
+  BlueprintGenerator,
+  BundleSchema,
   CriticalPathResolver,
   EntropyAnalyzer,
+  ProjectScanner,
   SecurityScanner,
   TypeScriptParser,
+  addProvenance,
   appendLearning,
   applyFixes,
   archiveStream,
@@ -84,32 +94,42 @@ import {
   checkDocCoverage,
   createFixes,
   createStream,
+  deepMergeConstraints,
   defineLayer,
   detectCircularDepsInFiles,
   detectDeadCode,
   detectDocDrift,
+  diff,
+  extractBundle,
   generateSuggestions,
   listStreams,
   loadState,
   loadStreamIndex,
   parseDiff,
+  parseManifest,
   parseSecurityConfig,
+  readLockfile,
+  removeContributions,
+  removeProvenance,
   requestPeerReview,
   resolveStreamPath,
+  runAll,
   runCIChecks,
   runReviewPipeline,
   setActiveStream,
   validateAgentsMap,
   validateDependencies,
-  validateKnowledgeMap
-} from "./chunk-NX6DSZSM.js";
+  validateKnowledgeMap,
+  writeConfig,
+  writeLockfile
+} from "./chunk-AE2OWWDH.js";
 import {
   Err,
   Ok
 } from "./chunk-MHBMTPW7.js";
 
 // src/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command53 } from "commander";
 
 // src/commands/validate.ts
 import { Command } from "commander";
@@ -188,7 +208,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-WZAX357V.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-LJX65SBS.js");
       const cwd = process.cwd();
       const specsDir = path.join(cwd, "docs", "specs");
       const plansDir = path.join(cwd, "docs", "plans");
@@ -314,13 +334,13 @@ function createCheckDepsCommand() {
 import { Command as Command3 } from "commander";
 import * as path3 from "path";
 async function runCheckPerf(cwd, options) {
-  const runAll = !options.structural && !options.size && !options.coupling;
+  const runAll2 = !options.structural && !options.size && !options.coupling;
   const analyzer = new EntropyAnalyzer({
     rootDir: path3.resolve(cwd),
     analyze: {
-      complexity: runAll || !!options.structural,
-      coupling: runAll || !!options.coupling,
-      sizeBudget: runAll || !!options.size
+      complexity: runAll2 || !!options.structural,
+      coupling: runAll2 || !!options.coupling,
+      sizeBudget: runAll2 || !!options.size
     }
   });
   const analysisResult = await analyzer.analyze();
@@ -456,10 +476,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path4.resolve(cwd);
   let configData = {};
   try {
-    const fs11 = await import("fs");
+    const fs23 = await import("fs");
     const configPath = path4.join(projectRoot, "harness.config.json");
-    if (fs11.existsSync(configPath)) {
-      const raw = fs11.readFileSync(configPath, "utf-8");
+    if (fs23.existsSync(configPath)) {
+      const raw = fs23.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -546,7 +566,7 @@ function createPerfCommand() {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-PBTNVK6K.js");
+    const { BenchmarkRunner } = await import("./dist-IJ4J4C5G.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
@@ -615,7 +635,7 @@ Results (${result.results.length} benchmarks):`);
   baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-PBTNVK6K.js");
+    const { BenchmarkRunner } = await import("./dist-IJ4J4C5G.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -628,8 +648,8 @@ Results (${result.results.length} benchmarks):`);
     }
     let commitHash = "unknown";
     try {
-      const { execSync: execSync3 } = await import("child_process");
-      commitHash = execSync3("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
+      const { execSync: execSync5 } = await import("child_process");
+      commitHash = execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
     } catch {
     }
     manager.save(benchResult.results, commitHash);
@@ -643,7 +663,7 @@ Results (${result.results.length} benchmarks):`);
   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-PBTNVK6K.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-IJ4J4C5G.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -717,7 +737,14 @@ async function runCheckDocs(options) {
   const coverageResult = await checkDocCoverage("project", {
     docsDir,
     sourceDir,
-    excludePatterns: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"]
+    excludePatterns: [
+      "**/*.test.ts",
+      "**/*.spec.ts",
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/coverage/**",
+      "**/.turbo/**"
+    ]
   });
   if (!coverageResult.ok) {
     return Err(
@@ -1396,22 +1423,22 @@ async function runAgentReview(options) {
     return configResult;
   }
   const config = configResult.value;
-  let diff;
+  let diff2;
   try {
-    diff = execSync2("git diff --cached", { encoding: "utf-8" });
-    if (!diff) {
-      diff = execSync2("git diff", { encoding: "utf-8" });
+    diff2 = execSync2("git diff --cached", { encoding: "utf-8" });
+    if (!diff2) {
+      diff2 = execSync2("git diff", { encoding: "utf-8" });
     }
   } catch {
     return Err(new CLIError("Failed to get git diff", ExitCode.ERROR));
   }
-  if (!diff) {
+  if (!diff2) {
     return Ok({
       passed: true,
       checklist: [{ check: "No changes to review", passed: true }]
     });
   }
-  const parsedDiffResult = parseDiff(diff);
+  const parsedDiffResult = parseDiff(diff2);
   if (!parsedDiffResult.ok) {
     return Err(new CLIError(parsedDiffResult.error.message, ExitCode.ERROR));
   }
@@ -1425,7 +1452,7 @@ async function runAgentReview(options) {
     changedFiles: codeChanges.files.map((f) => f.path),
     newFiles: codeChanges.files.filter((f) => f.status === "added").map((f) => f.path),
     deletedFiles: codeChanges.files.filter((f) => f.status === "deleted").map((f) => f.path),
-    totalDiffLines: diff.split("\n").length,
+    totalDiffLines: diff2.split("\n").length,
     fileDiffs: new Map(codeChanges.files.map((f) => [f.path, ""]))
   };
   const pipelineResult = await runReviewPipeline({
@@ -1592,7 +1619,7 @@ async function runAdd(componentType, name, options) {
         break;
       }
       case "skill": {
-        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-LUWO46WF.js");
+        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-WPXHSLX2.js");
         generateSkillFiles2({
           name,
           description: `${name} skill`,
@@ -1857,37 +1884,171 @@ function createPersonaCommand() {
 }
 
 // src/commands/skill/index.ts
-import { Command as Command25 } from "commander";
+import { Command as Command28 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command21 } from "commander";
+import * as fs6 from "fs";
+import * as path15 from "path";
+import { parse } from "yaml";
+
+// src/registry/lockfile.ts
 import * as fs5 from "fs";
 import * as path14 from "path";
-import { parse } from "yaml";
-function createListCommand2() {
-  return new Command21("list").description("List available skills").action(async (_opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const skillsDir = resolveSkillsDir();
-    if (!fs5.existsSync(skillsDir)) {
-      logger.info("No skills directory found.");
-      process.exit(ExitCode.SUCCESS);
-      return;
+function createEmptyLockfile() {
+  return { version: 1, skills: {} };
+}
+function sortedStringify(obj) {
+  return JSON.stringify(
+    obj,
+    (_key, value) => {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        return Object.keys(value).sort().reduce((sorted, k) => {
+          sorted[k] = value[k];
+          return sorted;
+        }, {});
+      }
+      return value;
+    },
+    2
+  );
+}
+function readLockfile2(filePath) {
+  if (!fs5.existsSync(filePath)) {
+    return createEmptyLockfile();
+  }
+  const raw = fs5.readFileSync(filePath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Failed to parse lockfile at ${filePath}. The file may be corrupted. Delete it and re-run harness install to regenerate.`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || !("version" in parsed) || parsed.version !== 1 || !("skills" in parsed) || typeof parsed.skills !== "object") {
+    throw new Error(
+      `Invalid lockfile format at ${filePath}. Expected version 1 with a skills object. Delete it and re-run harness install to regenerate.`
+    );
+  }
+  return parsed;
+}
+function writeLockfile2(filePath, lockfile) {
+  const dir = path14.dirname(filePath);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
+}
+function updateLockfileEntry(lockfile, name, entry) {
+  return {
+    ...lockfile,
+    skills: {
+      ...lockfile.skills,
+      [name]: entry
     }
-    const entries = fs5.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-    const skills = [];
-    for (const name of entries) {
-      const yamlPath = path14.join(skillsDir, name, "skill.yaml");
-      if (!fs5.existsSync(yamlPath)) continue;
-      try {
-        const raw = fs5.readFileSync(yamlPath, "utf-8");
-        const parsed = parse(raw);
-        const result = SkillMetadataSchema.safeParse(parsed);
-        if (result.success) {
-          skills.push(result.data);
-        }
-      } catch {
+  };
+}
+function removeLockfileEntry(lockfile, name) {
+  if (!(name in lockfile.skills)) {
+    return lockfile;
+  }
+  const { [name]: _removed, ...rest } = lockfile.skills;
+  return {
+    ...lockfile,
+    skills: rest
+  };
+}
+
+// src/commands/skill/list.ts
+function scanDirectory(dirPath, source) {
+  if (!fs6.existsSync(dirPath)) return [];
+  const entries = fs6.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  const skills = [];
+  for (const name of entries) {
+    const yamlPath = path15.join(dirPath, name, "skill.yaml");
+    if (!fs6.existsSync(yamlPath)) continue;
+    try {
+      const raw = fs6.readFileSync(yamlPath, "utf-8");
+      const parsed = parse(raw);
+      const result = SkillMetadataSchema.safeParse(parsed);
+      if (result.success) {
+        skills.push({
+          name: result.data.name,
+          description: result.data.description,
+          type: result.data.type,
+          source
+        });
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+function collectSkills(opts) {
+  const seen = /* @__PURE__ */ new Set();
+  const allSkills = [];
+  const addUnique = (entries) => {
+    for (const entry of entries) {
+      if (!seen.has(entry.name)) {
+        seen.add(entry.name);
+        allSkills.push(entry);
+      }
+    }
+  };
+  if (opts.filter === "all" || opts.filter === "local") {
+    const projectDir = resolveProjectSkillsDir();
+    if (projectDir) {
+      addUnique(scanDirectory(projectDir, "local"));
+    }
+  }
+  if (opts.filter === "all" || opts.filter === "installed") {
+    const globalDir = resolveGlobalSkillsDir();
+    const skillsDir = path15.dirname(globalDir);
+    const communityBase = path15.join(skillsDir, "community");
+    const communityPlatformDir = path15.join(communityBase, "claude-code");
+    const lockfilePath = path15.join(communityBase, "skills-lock.json");
+    const lockfile = readLockfile2(lockfilePath);
+    const communitySkills = scanDirectory(communityPlatformDir, "community");
+    for (const skill of communitySkills) {
+      const pkgName = `@harness-skills/${skill.name}`;
+      const lockEntry = lockfile.skills[pkgName];
+      if (lockEntry) {
+        skill.version = lockEntry.version;
+      }
+    }
+    addUnique(communitySkills);
+    for (const [pkgName, entry] of Object.entries(lockfile.skills)) {
+      const shortName = pkgName.replace("@harness-skills/", "");
+      if (!seen.has(shortName)) {
+        seen.add(shortName);
+        allSkills.push({
+          name: shortName,
+          description: "",
+          type: "",
+          source: "community",
+          version: entry.version
+        });
       }
     }
+  }
+  if (opts.filter === "all") {
+    const globalDir = resolveGlobalSkillsDir();
+    addUnique(scanDirectory(globalDir, "bundled"));
+  }
+  if (opts.filter === "installed") {
+    return allSkills.filter((s) => s.source === "community");
+  }
+  if (opts.filter === "local") {
+    return allSkills.filter((s) => s.source === "local");
+  }
+  return allSkills;
+}
+function createListCommand2() {
+  return new Command21("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();
+    let filter = "all";
+    if (opts.installed) filter = "installed";
+    else if (opts.local) filter = "local";
+    const skills = collectSkills({ filter });
     if (globalOpts.json) {
       logger.raw(skills);
     } else if (globalOpts.quiet) {
@@ -1898,9 +2059,12 @@ function createListCommand2() {
       } else {
         console.log("Available skills:\n");
         for (const s of skills) {
-          console.log(`  ${s.name} (${s.type})`);
-          console.log(`    ${s.description}
-`);
+          const version = s.version ? `@${s.version}` : "";
+          console.log(`  ${s.name}${version} [${s.source}] (${s.type || "unknown"})`);
+          if (s.description) {
+            console.log(`    ${s.description}`);
+          }
+          console.log();
         }
       }
     }
@@ -1910,8 +2074,8 @@ function createListCommand2() {
 
 // src/commands/skill/run.ts
 import { Command as Command22 } from "commander";
-import * as fs6 from "fs";
-import * as path15 from "path";
+import * as fs7 from "fs";
+import * as path16 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -2001,17 +2165,17 @@ ${options.priorState}`);
 function createRunCommand2() {
   return new Command22("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Complexity: auto, light, full", "auto").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts, _cmd) => {
     const skillsDir = resolveSkillsDir();
-    const skillDir = path15.join(skillsDir, name);
-    if (!fs6.existsSync(skillDir)) {
+    const skillDir = path16.join(skillsDir, name);
+    if (!fs7.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path15.join(skillDir, "skill.yaml");
+    const yamlPath = path16.join(skillDir, "skill.yaml");
     let metadata = null;
-    if (fs6.existsSync(yamlPath)) {
+    if (fs7.existsSync(yamlPath)) {
       try {
-        const raw = fs6.readFileSync(yamlPath, "utf-8");
+        const raw = fs7.readFileSync(yamlPath, "utf-8");
         const parsed = parse2(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) metadata = result.data;
@@ -2022,17 +2186,17 @@ function createRunCommand2() {
     if (metadata?.phases && metadata.phases.length > 0) {
       const requested = opts.complexity ?? "auto";
       if (requested === "auto") {
-        const projectPath2 = opts.path ? path15.resolve(opts.path) : process.cwd();
+        const projectPath2 = opts.path ? path16.resolve(opts.path) : process.cwd();
         complexity = detectComplexity(projectPath2);
       } else {
         complexity = requested;
       }
     }
     let principles;
-    const projectPath = opts.path ? path15.resolve(opts.path) : process.cwd();
-    const principlesPath = path15.join(projectPath, "docs", "principles.md");
-    if (fs6.existsSync(principlesPath)) {
-      principles = fs6.readFileSync(principlesPath, "utf-8");
+    const projectPath = opts.path ? path16.resolve(opts.path) : process.cwd();
+    const principlesPath = path16.join(projectPath, "docs", "principles.md");
+    if (fs7.existsSync(principlesPath)) {
+      principles = fs7.readFileSync(principlesPath, "utf-8");
     }
     let priorState;
     let stateWarning;
@@ -2047,16 +2211,16 @@ function createRunCommand2() {
       }
       if (metadata?.state.persistent && metadata.state.files.length > 0) {
         for (const stateFilePath of metadata.state.files) {
-          const fullPath = path15.join(projectPath, stateFilePath);
-          if (fs6.existsSync(fullPath)) {
-            const stat = fs6.statSync(fullPath);
+          const fullPath = path16.join(projectPath, stateFilePath);
+          if (fs7.existsSync(fullPath)) {
+            const stat = fs7.statSync(fullPath);
             if (stat.isDirectory()) {
-              const files = fs6.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs6.statSync(path15.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+              const files = fs7.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs7.statSync(path16.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
               if (files.length > 0) {
-                priorState = fs6.readFileSync(path15.join(fullPath, files[0].name), "utf-8");
+                priorState = fs7.readFileSync(path16.join(fullPath, files[0].name), "utf-8");
               }
             } else {
-              priorState = fs6.readFileSync(fullPath, "utf-8");
+              priorState = fs7.readFileSync(fullPath, "utf-8");
             }
             break;
           }
@@ -2075,17 +2239,17 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path15.join(skillDir, "SKILL.md");
-    if (!fs6.existsSync(skillMdPath)) {
+    const skillMdPath = path16.join(skillDir, "SKILL.md");
+    if (!fs7.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    let content = fs6.readFileSync(skillMdPath, "utf-8");
+    let content = fs7.readFileSync(skillMdPath, "utf-8");
     if (metadata?.state.persistent && opts.path) {
-      const stateFile = path15.join(projectPath, ".harness", "state.json");
-      if (fs6.existsSync(stateFile)) {
-        const stateContent = fs6.readFileSync(stateFile, "utf-8");
+      const stateFile = path16.join(projectPath, ".harness", "state.json");
+      if (fs7.existsSync(stateFile)) {
+        const stateContent = fs7.readFileSync(stateFile, "utf-8");
         content += `
 
 ---
@@ -2103,8 +2267,8 @@ ${stateContent}
 
 // src/commands/skill/validate.ts
 import { Command as Command23 } from "commander";
-import * as fs7 from "fs";
-import * as path16 from "path";
+import * as fs8 from "fs";
+import * as path17 from "path";
 import { parse as parse3 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
@@ -2117,32 +2281,32 @@ function createValidateCommand3() {
   return new Command23("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs7.existsSync(skillsDir)) {
+    if (!fs8.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path16.join(skillsDir, name);
-      const yamlPath = path16.join(skillDir, "skill.yaml");
-      const skillMdPath = path16.join(skillDir, "SKILL.md");
-      if (!fs7.existsSync(yamlPath)) {
+      const skillDir = path17.join(skillsDir, name);
+      const yamlPath = path17.join(skillDir, "skill.yaml");
+      const skillMdPath = path17.join(skillDir, "SKILL.md");
+      if (!fs8.existsSync(yamlPath)) {
         errors.push(`${name}: missing skill.yaml`);
         continue;
       }
       try {
-        const raw = fs7.readFileSync(yamlPath, "utf-8");
+        const raw = fs8.readFileSync(yamlPath, "utf-8");
         const parsed = parse3(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (!result.success) {
           errors.push(`${name}/skill.yaml: ${result.error.message}`);
           continue;
         }
-        if (fs7.existsSync(skillMdPath)) {
-          const mdContent = fs7.readFileSync(skillMdPath, "utf-8");
+        if (fs8.existsSync(skillMdPath)) {
+          const mdContent = fs8.readFileSync(skillMdPath, "utf-8");
           for (const section of REQUIRED_SECTIONS) {
             if (!mdContent.includes(section)) {
               errors.push(`${name}/SKILL.md: missing section "${section}"`);
@@ -2184,27 +2348,27 @@ function createValidateCommand3() {
 
 // src/commands/skill/info.ts
 import { Command as Command24 } from "commander";
-import * as fs8 from "fs";
-import * as path17 from "path";
+import * as fs9 from "fs";
+import * as path18 from "path";
 import { parse as parse4 } from "yaml";
 function createInfoCommand() {
   return new Command24("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    const skillDir = path17.join(skillsDir, name);
-    if (!fs8.existsSync(skillDir)) {
+    const skillDir = path18.join(skillsDir, name);
+    if (!fs9.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path17.join(skillDir, "skill.yaml");
-    if (!fs8.existsSync(yamlPath)) {
+    const yamlPath = path18.join(skillDir, "skill.yaml");
+    if (!fs9.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     try {
-      const raw = fs8.readFileSync(yamlPath, "utf-8");
+      const raw = fs9.readFileSync(yamlPath, "utf-8");
       const parsed = parse4(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
@@ -2243,974 +2407,2710 @@ function createInfoCommand() {
   });
 }
 
-// src/commands/skill/index.ts
-function createSkillCommand() {
-  const command = new Command25("skill").description("Skill management commands");
-  command.addCommand(createListCommand2());
-  command.addCommand(createRunCommand2());
-  command.addCommand(createValidateCommand3());
-  command.addCommand(createInfoCommand());
-  return command;
-}
-
-// src/commands/state/index.ts
-import { Command as Command30 } from "commander";
+// src/commands/skill/search.ts
+import { Command as Command25 } from "commander";
 
-// src/commands/state/show.ts
-import { Command as Command26 } from "commander";
-import * as path18 from "path";
-function createShowCommand() {
-  return new Command26("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path18.resolve(opts.path);
-    const result = await loadState(projectPath, opts.stream);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    const state = result.value;
-    if (globalOpts.json) {
-      logger.raw(state);
-    } else if (globalOpts.quiet) {
-      console.log(JSON.stringify(state));
-    } else {
-      if (opts.stream) console.log(`Stream:         ${opts.stream}`);
-      console.log(`Schema Version: ${state.schemaVersion}`);
-      if (state.position.phase) console.log(`Phase:          ${state.position.phase}`);
-      if (state.position.task) console.log(`Task:           ${state.position.task}`);
-      if (state.lastSession) {
-        console.log(`Last Session:   ${state.lastSession.date} \u2014 ${state.lastSession.summary}`);
-      }
-      if (Object.keys(state.progress).length > 0) {
-        console.log("\nProgress:");
-        for (const [task, status] of Object.entries(state.progress)) {
-          console.log(`  ${task}: ${status}`);
+// src/registry/npm-client.ts
+import * as fs10 from "fs";
+import * as path19 from "path";
+import * as os2 from "os";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 3e4;
+var HARNESS_SKILLS_SCOPE = "@harness-skills/";
+function resolvePackageName(name) {
+  if (name.startsWith(HARNESS_SKILLS_SCOPE)) {
+    return name;
+  }
+  if (name.startsWith("@")) {
+    throw new Error(`Only @harness-skills/ scoped packages are supported. Got: ${name}`);
+  }
+  return `${HARNESS_SKILLS_SCOPE}${name}`;
+}
+function extractSkillName(packageName) {
+  if (packageName.startsWith(HARNESS_SKILLS_SCOPE)) {
+    return packageName.slice(HARNESS_SKILLS_SCOPE.length);
+  }
+  return packageName;
+}
+function readNpmrcToken(registryUrl) {
+  const { hostname, pathname } = new URL(registryUrl);
+  const registryPath = `//${hostname}${pathname.replace(/\/$/, "")}/:_authToken=`;
+  const candidates = [path19.join(process.cwd(), ".npmrc"), path19.join(os2.homedir(), ".npmrc")];
+  for (const npmrcPath of candidates) {
+    try {
+      const content = fs10.readFileSync(npmrcPath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith(registryPath)) {
+          return trimmed.slice(registryPath.length).trim();
         }
       }
-      if (state.decisions.length > 0) {
-        console.log(`
-Decisions: ${state.decisions.length}`);
-      }
-      if (state.blockers.length > 0) {
-        const open = state.blockers.filter((b) => b.status === "open").length;
-        console.log(`Blockers:   ${open} open / ${state.blockers.length} total`);
-      }
+    } catch {
     }
-    process.exit(ExitCode.SUCCESS);
-  });
+  }
+  return null;
 }
-
-// src/commands/state/reset.ts
-import { Command as Command27 } from "commander";
-import * as fs9 from "fs";
-import * as path19 from "path";
-import * as readline from "readline";
-function createResetCommand() {
-  return new Command27("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
-    const projectPath = path19.resolve(opts.path);
-    let statePath;
-    if (opts.stream) {
-      const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
-      if (!streamResult.ok) {
-        logger.error(streamResult.error.message);
-        process.exit(ExitCode.ERROR);
-        return;
-      }
-      statePath = path19.join(streamResult.value, "state.json");
-    } else {
-      statePath = path19.join(projectPath, ".harness", "state.json");
-    }
-    if (!fs9.existsSync(statePath)) {
-      logger.info("No state file found. Nothing to reset.");
-      process.exit(ExitCode.SUCCESS);
-      return;
+async function fetchPackageMetadata(packageName, registryUrl) {
+  const registry = registryUrl ?? NPM_REGISTRY;
+  const headers = {};
+  if (registryUrl) {
+    const token = readNpmrcToken(registryUrl);
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+  }
+  const encodedName = encodeURIComponent(packageName);
+  const url = `${registry}/${encodedName}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      headers,
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+  } catch {
+    throw new Error("Cannot reach npm registry. Check your network connection.");
+  }
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Package ${packageName} not found on npm registry.`);
     }
-    if (!opts.yes) {
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve20) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve20);
+    throw new Error(
+      `npm registry returned ${response.status} ${response.statusText} for ${packageName}.`
+    );
+  }
+  return await response.json();
+}
+async function downloadTarball(tarballUrl, authToken) {
+  let lastError;
+  const headers = {};
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const response = await fetch(tarballUrl, {
+        headers,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
       });
-      rl.close();
-      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
-        logger.info("Reset cancelled.");
-        process.exit(ExitCode.SUCCESS);
-        return;
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`);
       }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
     }
-    try {
-      fs9.unlinkSync(statePath);
-      logger.success("Project state reset.");
-    } catch (e) {
-      logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    process.exit(ExitCode.SUCCESS);
-  });
+  }
+  throw new Error(`Download failed for ${tarballUrl}. Try again. (${lastError?.message})`);
+}
+async function searchNpmRegistry(query, registryUrl) {
+  const registry = registryUrl ?? NPM_REGISTRY;
+  const headers = {};
+  if (registryUrl) {
+    const token = readNpmrcToken(registryUrl);
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+  }
+  const searchText = encodeURIComponent(`scope:harness-skills ${query}`);
+  const url = `${registry}/-/v1/search?text=${searchText}&size=20`;
+  let response;
+  try {
+    response = await fetch(url, {
+      headers,
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+  } catch {
+    throw new Error("Cannot reach npm registry. Check your network connection.");
+  }
+  if (!response.ok) {
+    throw new Error(`npm registry search returned ${response.status} ${response.statusText}.`);
+  }
+  const data = await response.json();
+  return data.objects.map((obj) => ({
+    name: obj.package.name,
+    version: obj.package.version,
+    description: obj.package.description,
+    keywords: obj.package.keywords || [],
+    date: obj.package.date
+  }));
 }
 
-// src/commands/state/learn.ts
-import { Command as Command28 } from "commander";
-import * as path20 from "path";
-function createLearnCommand() {
-  return new Command28("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
-    const projectPath = path20.resolve(opts.path);
-    const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
+// src/commands/skill/search.ts
+async function runSearch(query, opts) {
+  const results = await searchNpmRegistry(query, opts.registry);
+  return results.filter((r) => {
+    if (opts.platform && !r.keywords.includes(opts.platform)) {
+      return false;
     }
-    logger.success(`Learning recorded.`);
-    process.exit(ExitCode.SUCCESS);
+    if (opts.trigger && !r.keywords.includes(opts.trigger)) {
+      return false;
+    }
+    return true;
   });
 }
-
-// src/commands/state/streams.ts
-import { Command as Command29 } from "commander";
-import * as path21 from "path";
-function createStreamsCommand() {
-  const command = new Command29("streams").description("Manage state streams");
-  command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
+function createSearchCommand() {
+  return new Command25("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) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path21.resolve(opts.path);
-    const indexResult = await loadStreamIndex(projectPath);
-    const result = await listStreams(projectPath);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    const active = indexResult.ok ? indexResult.value.activeStream : null;
-    if (globalOpts.json) {
-      logger.raw({ activeStream: active, streams: result.value });
-    } else {
-      if (result.value.length === 0) {
-        console.log("No streams found.");
+    try {
+      const results = await runSearch(query, opts);
+      if (globalOpts.json) {
+        logger.raw(results);
+        process.exit(ExitCode.SUCCESS);
+        return;
       }
-      for (const s of result.value) {
-        const marker = s.name === active ? " (active)" : "";
-        const branch = s.branch ? ` [${s.branch}]` : "";
-        console.log(`  ${s.name}${marker}${branch} \u2014 last active: ${s.lastActiveAt}`);
+      if (results.length === 0) {
+        logger.info(`No skills found matching "${query}".`);
+        process.exit(ExitCode.SUCCESS);
+        return;
+      }
+      console.log(`
+Found ${results.length} skill(s):
+`);
+      for (const r of results) {
+        const shortName = extractSkillName(r.name);
+        console.log(`  ${shortName}@${r.version}`);
+        console.log(`    ${r.description}`);
+        if (r.keywords.length > 0) {
+          console.log(`    keywords: ${r.keywords.join(", ")}`);
+        }
+        console.log();
       }
+      logger.info(`Install with: harness install <skill-name>`);
+      process.exit(ExitCode.SUCCESS);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(ExitCode.VALIDATION_FAILED);
     }
-    process.exit(ExitCode.SUCCESS);
   });
-  command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
-    const result = await createStream(projectPath, name, opts.branch);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Stream '${name}' created.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-  command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
-    const result = await archiveStream(projectPath, name);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Stream '${name}' archived.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-  command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
-    const result = await setActiveStream(projectPath, name);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Active stream set to '${name}'.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-  return command;
 }
 
-// src/commands/state/index.ts
-function createStateCommand() {
-  const command = new Command30("state").description("Project state management commands");
-  command.addCommand(createShowCommand());
-  command.addCommand(createResetCommand());
-  command.addCommand(createLearnCommand());
-  command.addCommand(createStreamsCommand());
-  return command;
-}
+// src/commands/skill/create.ts
+import { Command as Command26 } from "commander";
+import * as path20 from "path";
+import * as fs11 from "fs";
+import YAML from "yaml";
+var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+function buildReadme(name, description) {
+  return `# @harness-skills/${name}
 
-// src/commands/ci/index.ts
-import { Command as Command33 } from "commander";
+${description}
 
-// src/commands/ci/check.ts
-import { Command as Command31 } from "commander";
-var VALID_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
-async function runCICheck(options) {
-  const configResult = resolveConfig(options.configPath);
-  if (!configResult.ok) {
-    return configResult;
-  }
-  const input = {
-    projectRoot: process.cwd(),
-    config: configResult.value
+## Installation
+
+\`\`\`bash
+harness install ${name}
+\`\`\`
+
+## Usage
+
+This skill is automatically available after installation. Invoke it via:
+
+\`\`\`bash
+harness skill run ${name}
+\`\`\`
+
+Or use the slash command \`/${name}\` in your AI coding assistant.
+
+## Development
+
+Edit \`skill.yaml\` to configure the skill metadata and \`SKILL.md\` to define the skill's behavior.
+
+### Validate
+
+\`\`\`bash
+harness skill validate ${name}
+\`\`\`
+
+### Publish
+
+\`\`\`bash
+harness skills publish
+\`\`\`
+`;
+}
+function buildSkillYaml(name, opts) {
+  const platforms = opts.platforms ? opts.platforms.split(",").map((p) => p.trim()) : ["claude-code"];
+  const triggers = opts.triggers ? opts.triggers.split(",").map((t) => t.trim()) : ["manual"];
+  return {
+    name,
+    version: "0.1.0",
+    description: opts.description || `A community skill: ${name}`,
+    triggers,
+    platforms,
+    tools: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
+    type: opts.type || "flexible",
+    state: {
+      persistent: false,
+      files: []
+    },
+    depends_on: []
   };
-  if (options.skip) input.skip = options.skip;
-  if (options.failOn) input.failOn = options.failOn;
-  const result = await runCIChecks(input);
-  if (!result.ok) {
-    return {
-      ok: false,
-      error: new CLIError(result.error.message, ExitCode.ERROR)
-    };
-  }
-  return { ok: true, value: result.value };
 }
-function parseSkip(skip) {
-  if (!skip) return [];
-  return skip.split(",").map((s) => s.trim()).filter((s) => VALID_CHECKS.includes(s));
+function buildSkillMd(name, description) {
+  return `# ${name}
+
+${description}
+
+## When to Use
+
+- [Describe when this skill should be invoked]
+- [Describe the trigger conditions]
+
+## Process
+
+1. [Describe the step-by-step process]
+2. [Add additional steps as needed]
+
+## Success Criteria
+
+- [Define what a successful execution looks like]
+- [Add measurable criteria]
+`;
 }
-function parseFailOn(failOn) {
-  if (failOn === "warning") return "warning";
-  return "error";
+function runCreate(name, opts) {
+  if (!KEBAB_CASE_RE.test(name)) {
+    throw new Error(`Invalid skill name "${name}". Must be kebab-case (e.g., my-skill).`);
+  }
+  const baseDir = opts.outputDir ?? path20.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path20.join(baseDir, name);
+  if (fs11.existsSync(skillDir)) {
+    throw new Error(`Skill directory already exists: ${skillDir}`);
+  }
+  fs11.mkdirSync(skillDir, { recursive: true });
+  const description = opts.description || `A community skill: ${name}`;
+  const skillYaml = buildSkillYaml(name, opts);
+  const skillYamlPath = path20.join(skillDir, "skill.yaml");
+  fs11.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillMd = buildSkillMd(name, description);
+  const skillMdPath = path20.join(skillDir, "SKILL.md");
+  fs11.writeFileSync(skillMdPath, skillMd);
+  const readme = buildReadme(name, description);
+  const readmePath = path20.join(skillDir, "README.md");
+  fs11.writeFileSync(readmePath, readme);
+  return {
+    name,
+    directory: skillDir,
+    files: [skillYamlPath, skillMdPath, readmePath]
+  };
 }
-function createCheckCommand() {
-  return new Command31("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+function createCreateCommand() {
+  return new Command26("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();
-    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
-    const skip = parseSkip(opts.skip);
-    const failOn = parseFailOn(opts.failOn);
-    const result = await runCICheck({
-      configPath: globalOpts.config,
-      skip,
-      failOn
-    });
-    if (!result.ok) {
-      if (mode === OutputMode.JSON) {
-        console.log(JSON.stringify({ error: result.error.message }));
+    try {
+      const result = runCreate(name, {
+        description: opts.description,
+        type: opts.type,
+        platforms: opts.platforms,
+        triggers: opts.triggers,
+        outputDir: opts.outputDir
+      });
+      if (globalOpts.json) {
+        logger.raw(result);
       } else {
-        logger.error(result.error.message);
-      }
-      process.exit(ExitCode.ERROR);
-    }
-    const report = result.value;
-    if (mode === OutputMode.JSON) {
-      console.log(JSON.stringify(report, null, 2));
-    } else if (mode !== OutputMode.QUIET) {
-      for (const check of report.checks) {
-        const logFn = check.status === "pass" ? logger.success : check.status === "fail" ? logger.error : check.status === "warn" ? logger.warn : logger.dim;
-        logFn(`${check.name}: ${check.status} (${check.durationMs}ms)`);
-        for (const issue of check.issues) {
-          const prefix = issue.severity === "error" ? "  x" : "  !";
-          console.log(`${prefix} ${issue.message}${issue.file ? ` (${issue.file})` : ""}`);
+        logger.success(`Created skill "${name}"`);
+        for (const f of result.files) {
+          logger.info(`  ${f}`);
         }
-      }
-      console.log("");
-      if (report.exitCode === 0) {
-        logger.success(`All checks passed (${report.summary.passed}/${report.summary.total})`);
-      } else {
-        logger.error(
-          `${report.summary.failed} failed, ${report.summary.warnings} warnings, ${report.summary.passed} passed`
+        logger.info(`
+Next steps:`);
+        logger.info(
+          `  1. Edit ${path20.join(result.directory, "SKILL.md")} with your skill content`
         );
+        logger.info(`  2. Run: harness skill validate ${name}`);
+        logger.info(`  3. Run: harness skills publish`);
       }
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(ExitCode.VALIDATION_FAILED);
     }
-    process.exit(report.exitCode);
   });
 }
 
-// src/commands/ci/init.ts
-import { Command as Command32 } from "commander";
-import * as fs10 from "fs";
-import * as path22 from "path";
-var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
-function buildSkipFlag(checks) {
-  if (!checks) return "";
-  const skipChecks = ALL_CHECKS.filter((c) => !checks.includes(c));
-  if (skipChecks.length === 0) return "";
-  return ` --skip ${skipChecks.join(",")}`;
-}
-function generateGitHubActions(skipFlag) {
-  return `name: Harness Checks
+// src/commands/skill/publish.ts
+import { Command as Command27 } from "commander";
+import * as fs14 from "fs";
+import * as path23 from "path";
+import { execFileSync as execFileSync3 } from "child_process";
 
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
+// src/registry/validator.ts
+import * as fs13 from "fs";
+import * as path22 from "path";
+import { parse as parse5 } from "yaml";
+import semver from "semver";
 
-concurrency:
-  group: harness-\${{ github.ref }}
-  cancel-in-progress: true
+// src/registry/bundled-skills.ts
+import * as fs12 from "fs";
+import * as path21 from "path";
+function getBundledSkillNames(bundledSkillsDir) {
+  if (!fs12.existsSync(bundledSkillsDir)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const entries = fs12.readdirSync(bundledSkillsDir);
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    try {
+      const stat = fs12.statSync(path21.join(bundledSkillsDir, String(entry)));
+      if (stat.isDirectory()) {
+        names.add(String(entry));
+      }
+    } catch {
+    }
+  }
+  return names;
+}
 
-jobs:
-  harness:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-      - run: npm install -g @harness-engineering/cli
-      - name: Run harness checks
-        run: harness ci check --json${skipFlag}
-`;
+// src/registry/validator.ts
+async function validateForPublish(skillDir, registryUrl) {
+  const errors = [];
+  const skillYamlPath = path22.join(skillDir, "skill.yaml");
+  if (!fs13.existsSync(skillYamlPath)) {
+    errors.push("skill.yaml not found. Create one with: harness skill create <name>");
+    return { valid: false, errors };
+  }
+  let skillMeta;
+  try {
+    const raw = fs13.readFileSync(skillYamlPath, "utf-8");
+    const parsed = parse5(raw);
+    const result = SkillMetadataSchema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      errors.push(`skill.yaml validation failed: ${issues}`);
+      return { valid: false, errors };
+    }
+    skillMeta = result.data;
+  } catch (err) {
+    errors.push(`Failed to parse skill.yaml: ${err instanceof Error ? err.message : String(err)}`);
+    return { valid: false, errors };
+  }
+  if (!skillMeta.description || skillMeta.description.trim().length === 0) {
+    errors.push("description must not be empty. Add a meaningful description to skill.yaml.");
+  }
+  if (!skillMeta.platforms || skillMeta.platforms.length === 0) {
+    errors.push("At least one platform is required. Add platforms to skill.yaml.");
+  }
+  if (!skillMeta.triggers || skillMeta.triggers.length === 0) {
+    errors.push("At least one trigger is required. Add triggers to skill.yaml.");
+  }
+  const skillMdPath = path22.join(skillDir, "SKILL.md");
+  if (!fs13.existsSync(skillMdPath)) {
+    errors.push("SKILL.md not found. Create it with content describing your skill.");
+  } else {
+    const content = fs13.readFileSync(skillMdPath, "utf-8");
+    if (!content.includes("## When to Use")) {
+      errors.push('SKILL.md must contain a "## When to Use" section.');
+    }
+    if (!content.includes("## Process")) {
+      errors.push('SKILL.md must contain a "## Process" section.');
+    }
+  }
+  const globalSkillsDir = resolveGlobalSkillsDir();
+  const bundledNames = getBundledSkillNames(globalSkillsDir);
+  if (bundledNames.has(skillMeta.name)) {
+    errors.push(
+      `Skill name "${skillMeta.name}" conflicts with a bundled skill. Choose a different name.`
+    );
+  }
+  try {
+    const packageName = resolvePackageName(skillMeta.name);
+    const metadata = await fetchPackageMetadata(packageName, registryUrl);
+    const publishedVersion = metadata["dist-tags"]?.latest;
+    if (publishedVersion && !semver.gt(skillMeta.version, publishedVersion)) {
+      errors.push(
+        `Version ${skillMeta.version} must be greater than published version ${publishedVersion}. Bump the version in skill.yaml.`
+      );
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("not found")) {
+      errors.push(`Cannot verify version against npm registry: ${msg}`);
+    }
+  }
+  if (skillMeta.depends_on && skillMeta.depends_on.length > 0) {
+    for (const dep of skillMeta.depends_on) {
+      if (bundledNames.has(dep)) continue;
+      try {
+        const depPkg = resolvePackageName(dep);
+        await fetchPackageMetadata(depPkg, registryUrl);
+      } catch {
+        errors.push(
+          `Dependency "${dep}" not found on npm or as a bundled skill. Publish it first or remove from depends_on.`
+        );
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    ...skillMeta ? { skillMeta } : {}
+  };
 }
-function generateGitLabCI(skipFlag) {
-  return `harness:
-  stage: test
-  image: node:22
-  before_script:
-    - npm install -g @harness-engineering/cli
-  script:
-    - harness ci check --json${skipFlag}
-  rules:
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-`;
+
+// src/skill/package-json.ts
+function derivePackageJson(skill) {
+  const keywords = ["harness-skill", ...skill.platforms, ...skill.triggers];
+  const pkg = {
+    name: `@harness-skills/${skill.name}`,
+    version: skill.version,
+    description: skill.description,
+    keywords,
+    files: ["skill.yaml", "SKILL.md", "README.md"],
+    license: "MIT"
+  };
+  if (skill.repository) {
+    pkg.repository = {
+      type: "git",
+      url: skill.repository
+    };
+  }
+  return pkg;
 }
-function generateGenericScript(skipFlag) {
-  return `#!/usr/bin/env bash
-set -euo pipefail
 
-# Harness CI Check Script
-# Generated by: harness ci init --platform generic
+// src/commands/skill/publish.ts
+async function runPublish(skillDir, opts) {
+  const validation = await validateForPublish(skillDir, opts.registry);
+  if (!validation.valid) {
+    const errorList = validation.errors.map((e) => `  - ${e}`).join("\n");
+    throw new Error(`Pre-publish validation failed:
+${errorList}`);
+  }
+  const meta = validation.skillMeta;
+  const pkg = derivePackageJson(meta);
+  const pkgPath = path23.join(skillDir, "package.json");
+  fs14.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path23.join(skillDir, "README.md");
+  if (!fs14.existsSync(readmePath)) {
+    const skillMdContent = fs14.readFileSync(path23.join(skillDir, "SKILL.md"), "utf-8");
+    const readme = `# ${pkg.name}
 
-if ! command -v harness &> /dev/null; then
-  echo "Installing @harness-engineering/cli..."
-  npm install -g @harness-engineering/cli
-fi
+${meta.description}
 
-echo "Running harness checks..."
-harness ci check --json${skipFlag}
-EXIT_CODE=$?
+## Installation
 
-if [ $EXIT_CODE -eq 0 ]; then
-  echo "All harness checks passed."
-elif [ $EXIT_CODE -eq 1 ]; then
-  echo "Harness checks failed. See report above."
-else
-  echo "Harness internal error."
-fi
+\`\`\`bash
+harness install ${meta.name}
+\`\`\`
 
-exit $EXIT_CODE
-`;
-}
-function generateCIConfig(options) {
-  const { platform, checks } = options;
-  const skipFlag = buildSkipFlag(checks);
-  const generators = {
-    github: { filename: ".github/workflows/harness.yml", generate: generateGitHubActions },
-    gitlab: { filename: ".gitlab-ci-harness.yml", generate: generateGitLabCI },
-    generic: { filename: "harness-ci.sh", generate: generateGenericScript }
-  };
-  const entry = generators[platform];
-  if (!entry) {
-    return Err(new CLIError(`Unknown platform: ${platform}`, ExitCode.ERROR));
+---
+
+${skillMdContent}`;
+    fs14.writeFileSync(readmePath, readme);
   }
-  return Ok({
-    filename: entry.filename,
-    content: entry.generate(skipFlag)
+  if (opts.dryRun) {
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      published: false,
+      dryRun: true
+    };
+  }
+  const publishArgs = ["publish", "--access", "public"];
+  if (opts.registry) {
+    publishArgs.push("--registry", opts.registry);
+  }
+  execFileSync3("npm", publishArgs, {
+    cwd: skillDir,
+    stdio: "pipe",
+    timeout: 6e4
   });
+  return {
+    name: pkg.name,
+    version: pkg.version,
+    published: true
+  };
 }
-function detectPlatform() {
-  if (fs10.existsSync(".github")) return "github";
-  if (fs10.existsSync(".gitlab-ci.yml")) return "gitlab";
-  return null;
+function createPublishCommand() {
+  return new Command27("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 {
+      const result = await runPublish(skillDir, {
+        dryRun: opts.dryRun,
+        registry: opts.registry
+      });
+      if (globalOpts.json) {
+        logger.raw(result);
+      } else if (result.dryRun) {
+        logger.success(`Validation passed. Would publish: ${result.name}@${result.version}`);
+        logger.info("Run without --dry-run to publish.");
+      } else {
+        logger.success(`Published ${result.name}@${result.version}`);
+      }
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(ExitCode.VALIDATION_FAILED);
+    }
+  });
 }
-function createInitCommand2() {
-  return new Command32("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
+
+// src/commands/skill/index.ts
+function createSkillCommand() {
+  const command = new Command28("skill").description("Skill management commands");
+  command.addCommand(createListCommand2());
+  command.addCommand(createRunCommand2());
+  command.addCommand(createValidateCommand3());
+  command.addCommand(createInfoCommand());
+  command.addCommand(createSearchCommand());
+  command.addCommand(createCreateCommand());
+  command.addCommand(createPublishCommand());
+  return command;
+}
+
+// src/commands/state/index.ts
+import { Command as Command33 } from "commander";
+
+// src/commands/state/show.ts
+import { Command as Command29 } from "commander";
+import * as path24 from "path";
+function createShowCommand() {
+  return new Command29("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const platform = opts.platform ?? detectPlatform() ?? "generic";
-    const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
-    const opts2 = { platform };
-    if (checks) opts2.checks = checks;
-    const result = generateCIConfig(opts2);
+    const projectPath = path24.resolve(opts.path);
+    const result = await loadState(projectPath, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
-      process.exit(result.error.exitCode);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    const state = result.value;
+    if (globalOpts.json) {
+      logger.raw(state);
+    } else if (globalOpts.quiet) {
+      console.log(JSON.stringify(state));
+    } else {
+      if (opts.stream) console.log(`Stream:         ${opts.stream}`);
+      console.log(`Schema Version: ${state.schemaVersion}`);
+      if (state.position.phase) console.log(`Phase:          ${state.position.phase}`);
+      if (state.position.task) console.log(`Task:           ${state.position.task}`);
+      if (state.lastSession) {
+        console.log(`Last Session:   ${state.lastSession.date} \u2014 ${state.lastSession.summary}`);
+      }
+      if (Object.keys(state.progress).length > 0) {
+        console.log("\nProgress:");
+        for (const [task, status] of Object.entries(state.progress)) {
+          console.log(`  ${task}: ${status}`);
+        }
+      }
+      if (state.decisions.length > 0) {
+        console.log(`
+Decisions: ${state.decisions.length}`);
+      }
+      if (state.blockers.length > 0) {
+        const open = state.blockers.filter((b) => b.status === "open").length;
+        console.log(`Blockers:   ${open} open / ${state.blockers.length} total`);
+      }
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/state/reset.ts
+import { Command as Command30 } from "commander";
+import * as fs15 from "fs";
+import * as path25 from "path";
+import * as readline from "readline";
+function createResetCommand() {
+  return new Command30("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
+    const projectPath = path25.resolve(opts.path);
+    let statePath;
+    if (opts.stream) {
+      const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
+      if (!streamResult.ok) {
+        logger.error(streamResult.error.message);
+        process.exit(ExitCode.ERROR);
+        return;
+      }
+      statePath = path25.join(streamResult.value, "state.json");
+    } else {
+      statePath = path25.join(projectPath, ".harness", "state.json");
+    }
+    if (!fs15.existsSync(statePath)) {
+      logger.info("No state file found. Nothing to reset.");
+      process.exit(ExitCode.SUCCESS);
+      return;
+    }
+    if (!opts.yes) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve27) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve27);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        logger.info("Reset cancelled.");
+        process.exit(ExitCode.SUCCESS);
+        return;
+      }
+    }
+    try {
+      fs15.unlinkSync(statePath);
+      logger.success("Project state reset.");
+    } catch (e) {
+      logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/state/learn.ts
+import { Command as Command31 } from "commander";
+import * as path26 from "path";
+function createLearnCommand() {
+  return new Command31("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
+    const projectPath = path26.resolve(opts.path);
+    const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Learning recorded.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/state/streams.ts
+import { Command as Command32 } from "commander";
+import * as path27 from "path";
+function createStreamsCommand() {
+  const command = new Command32("streams").description("Manage state streams");
+  command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path27.resolve(opts.path);
+    const indexResult = await loadStreamIndex(projectPath);
+    const result = await listStreams(projectPath);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    const active = indexResult.ok ? indexResult.value.activeStream : null;
+    if (globalOpts.json) {
+      logger.raw({ activeStream: active, streams: result.value });
+    } else {
+      if (result.value.length === 0) {
+        console.log("No streams found.");
+      }
+      for (const s of result.value) {
+        const marker = s.name === active ? " (active)" : "";
+        const branch = s.branch ? ` [${s.branch}]` : "";
+        console.log(`  ${s.name}${marker}${branch} \u2014 last active: ${s.lastActiveAt}`);
+      }
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await createStream(projectPath, name, opts.branch);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Stream '${name}' created.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await archiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Stream '${name}' archived.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
+    const projectPath = path27.resolve(opts.path);
+    const result = await setActiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Active stream set to '${name}'.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+// src/commands/state/index.ts
+function createStateCommand() {
+  const command = new Command33("state").description("Project state management commands");
+  command.addCommand(createShowCommand());
+  command.addCommand(createResetCommand());
+  command.addCommand(createLearnCommand());
+  command.addCommand(createStreamsCommand());
+  return command;
+}
+
+// src/commands/ci/index.ts
+import { Command as Command36 } from "commander";
+
+// src/commands/ci/check.ts
+import { Command as Command34 } from "commander";
+var VALID_CHECKS = [
+  "validate",
+  "deps",
+  "docs",
+  "entropy",
+  "security",
+  "perf",
+  "phase-gate",
+  "arch"
+];
+async function runCICheck(options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const input = {
+    projectRoot: process.cwd(),
+    config: configResult.value
+  };
+  if (options.skip) input.skip = options.skip;
+  if (options.failOn) input.failOn = options.failOn;
+  const result = await runCIChecks(input);
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: new CLIError(result.error.message, ExitCode.ERROR)
+    };
+  }
+  return { ok: true, value: result.value };
+}
+function parseSkip(skip) {
+  if (!skip) return [];
+  return skip.split(",").map((s) => s.trim()).filter((s) => VALID_CHECKS.includes(s));
+}
+function parseFailOn(failOn) {
+  if (failOn === "warning") return "warning";
+  return "error";
+}
+function createCheckCommand() {
+  return new Command34("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate, arch)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const skip = parseSkip(opts.skip);
+    const failOn = parseFailOn(opts.failOn);
+    const result = await runCICheck({
+      configPath: globalOpts.config,
+      skip,
+      failOn
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(ExitCode.ERROR);
+    }
+    const report = result.value;
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify(report, null, 2));
+    } else if (mode !== OutputMode.QUIET) {
+      for (const check of report.checks) {
+        const logFn = check.status === "pass" ? logger.success : check.status === "fail" ? logger.error : check.status === "warn" ? logger.warn : logger.dim;
+        logFn(`${check.name}: ${check.status} (${check.durationMs}ms)`);
+        for (const issue of check.issues) {
+          const prefix = issue.severity === "error" ? "  x" : "  !";
+          console.log(`${prefix} ${issue.message}${issue.file ? ` (${issue.file})` : ""}`);
+        }
+      }
+      console.log("");
+      if (report.exitCode === 0) {
+        logger.success(`All checks passed (${report.summary.passed}/${report.summary.total})`);
+      } else {
+        logger.error(
+          `${report.summary.failed} failed, ${report.summary.warnings} warnings, ${report.summary.passed} passed`
+        );
+      }
+    }
+    process.exit(report.exitCode);
+  });
+}
+
+// src/commands/ci/init.ts
+import { Command as Command35 } from "commander";
+import * as fs16 from "fs";
+import * as path28 from "path";
+var ALL_CHECKS = [
+  "validate",
+  "deps",
+  "docs",
+  "entropy",
+  "security",
+  "perf",
+  "phase-gate",
+  "arch"
+];
+function buildSkipFlag(checks) {
+  if (!checks) return "";
+  const skipChecks = ALL_CHECKS.filter((c) => !checks.includes(c));
+  if (skipChecks.length === 0) return "";
+  return ` --skip ${skipChecks.join(",")}`;
+}
+function generateGitHubActions(skipFlag) {
+  return `name: Harness Checks
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: harness-\${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  harness:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npm install -g @harness-engineering/cli
+      - name: Run harness checks
+        run: harness ci check --json${skipFlag}
+`;
+}
+function generateGitLabCI(skipFlag) {
+  return `harness:
+  stage: test
+  image: node:22
+  before_script:
+    - npm install -g @harness-engineering/cli
+  script:
+    - harness ci check --json${skipFlag}
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+`;
+}
+function generateGenericScript(skipFlag) {
+  return `#!/usr/bin/env bash
+set -euo pipefail
+
+# Harness CI Check Script
+# Generated by: harness ci init --platform generic
+
+if ! command -v harness &> /dev/null; then
+  echo "Installing @harness-engineering/cli..."
+  npm install -g @harness-engineering/cli
+fi
+
+echo "Running harness checks..."
+harness ci check --json${skipFlag}
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -eq 0 ]; then
+  echo "All harness checks passed."
+elif [ $EXIT_CODE -eq 1 ]; then
+  echo "Harness checks failed. See report above."
+else
+  echo "Harness internal error."
+fi
+
+exit $EXIT_CODE
+`;
+}
+function generateCIConfig(options) {
+  const { platform, checks } = options;
+  const skipFlag = buildSkipFlag(checks);
+  const generators = {
+    github: { filename: ".github/workflows/harness.yml", generate: generateGitHubActions },
+    gitlab: { filename: ".gitlab-ci-harness.yml", generate: generateGitLabCI },
+    generic: { filename: "harness-ci.sh", generate: generateGenericScript }
+  };
+  const entry = generators[platform];
+  if (!entry) {
+    return Err(new CLIError(`Unknown platform: ${platform}`, ExitCode.ERROR));
+  }
+  return Ok({
+    filename: entry.filename,
+    content: entry.generate(skipFlag)
+  });
+}
+function detectPlatform() {
+  if (fs16.existsSync(".github")) return "github";
+  if (fs16.existsSync(".gitlab-ci.yml")) return "gitlab";
+  return null;
+}
+function createInitCommand2() {
+  return new Command35("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const platform = opts.platform ?? detectPlatform() ?? "generic";
+    const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
+    const opts2 = { platform };
+    if (checks) opts2.checks = checks;
+    const result = generateCIConfig(opts2);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(result.error.exitCode);
+    }
+    const { filename, content } = result.value;
+    const targetPath = path28.resolve(filename);
+    const dir = path28.dirname(targetPath);
+    fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(targetPath, content);
+    if (platform === "generic" && process.platform !== "win32") {
+      fs16.chmodSync(targetPath, "755");
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ file: filename, platform }));
+    } else {
+      logger.success(`Generated ${filename} for ${platform}`);
+      logger.dim("Run 'harness ci check' to test locally");
+    }
+  });
+}
+
+// src/commands/ci/index.ts
+function createCICommand() {
+  const command = new Command36("ci").description("CI/CD integration commands");
+  command.addCommand(createCheckCommand());
+  command.addCommand(createInitCommand2());
+  return command;
+}
+
+// src/commands/update.ts
+import { Command as Command37 } from "commander";
+import { execFileSync as execFileSync4 } from "child_process";
+import { realpathSync } from "fs";
+import readline2 from "readline";
+import chalk3 from "chalk";
+function detectPackageManager() {
+  try {
+    const argv1 = process.argv[1];
+    if (!argv1) return "npm";
+    const binPath = realpathSync(argv1);
+    const normalizedBin = binPath.replace(/\\/g, "/");
+    if (normalizedBin.includes("pnpm/global/") || // eslint-disable-line @harness-engineering/no-hardcoded-path-separator -- platform-safe
+    normalizedBin.includes("pnpm-global/")) {
+      return "pnpm";
+    }
+    if (normalizedBin.includes(".yarn/")) {
+      return "yarn";
+    }
+  } catch {
+  }
+  return "npm";
+}
+function getLatestVersion(pkg = "@harness-engineering/cli") {
+  const output = execFileSync4("npm", ["view", pkg, "dist-tags.latest"], {
+    encoding: "utf-8",
+    timeout: 15e3
+  });
+  return output.trim();
+}
+function getInstalledVersion(pm) {
+  try {
+    const output = execFileSync4(pm, ["list", "-g", "@harness-engineering/cli", "--json"], {
+      encoding: "utf-8",
+      timeout: 15e3
+    });
+    const data = JSON.parse(output);
+    const deps = data.dependencies ?? {};
+    return deps["@harness-engineering/cli"]?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function getInstalledPackages(pm) {
+  try {
+    const output = execFileSync4(pm, ["list", "-g", "--json"], {
+      encoding: "utf-8",
+      timeout: 15e3
+    });
+    const data = JSON.parse(output);
+    const deps = data.dependencies ?? {};
+    return Object.keys(deps).filter((name) => name.startsWith("@harness-engineering/"));
+  } catch {
+    return ["@harness-engineering/cli", "@harness-engineering/core"];
+  }
+}
+function prompt(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve27) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve27(answer.trim().toLowerCase());
+    });
+  });
+}
+function createUpdateCommand() {
+  return new Command37("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const pm = detectPackageManager();
+    if (globalOpts.verbose) {
+      logger.info(`Detected package manager: ${pm}`);
+    }
+    const currentVersion = getInstalledVersion(pm);
+    let latestCliVersion;
+    if (!opts.version) {
+      logger.info("Checking for updates...");
+      try {
+        latestCliVersion = getLatestVersion();
+      } catch {
+        logger.error("Failed to fetch latest version from npm registry");
+        return process.exit(ExitCode.ERROR);
+      }
+      if (currentVersion && currentVersion === latestCliVersion) {
+        logger.success(`Already up to date (v${currentVersion})`);
+        process.exit(ExitCode.SUCCESS);
+      }
+      if (currentVersion) {
+        console.log("");
+        logger.info(`Current CLI version: ${chalk3.dim(`v${currentVersion}`)}`);
+        logger.info(`Latest CLI version:  ${chalk3.green(`v${latestCliVersion}`)}`);
+        console.log("");
+      }
+    }
+    const packages = getInstalledPackages(pm);
+    if (globalOpts.verbose) {
+      logger.info(`Installed packages: ${packages.join(", ")}`);
+    }
+    const installPkgs = packages.map((pkg) => {
+      if (opts.version && pkg === "@harness-engineering/cli") {
+        return `${pkg}@${opts.version}`;
+      }
+      return `${pkg}@latest`;
+    });
+    const installCmd = `${pm} install -g ${installPkgs.join(" ")}`;
+    if (globalOpts.verbose) {
+      logger.info(`Running: ${installCmd}`);
+    }
+    try {
+      logger.info("Updating packages...");
+      execFileSync4(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
+      console.log("");
+      logger.success("Update complete");
+    } catch {
+      console.log("");
+      logger.error("Update failed. You can try manually:");
+      console.log(`  ${chalk3.cyan(installCmd)}`);
+      process.exit(ExitCode.ERROR);
+    }
+    console.log("");
+    const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (Y/n) ");
+    if (regenAnswer !== "n" && regenAnswer !== "no") {
+      const scopeAnswer = await prompt("Generate for (G)lobal or (l)ocal project? (G/l) ");
+      const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
+      try {
+        execFileSync4("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+          stdio: "inherit"
+        });
+      } catch {
+        logger.warn("Generation failed. Run manually:");
+        console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+      }
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+}
+
+// src/commands/generate.ts
+import { Command as Command38 } from "commander";
+function createGenerateCommand3() {
+  return new Command38("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const platforms = opts.platforms.split(",").map((p) => p.trim());
+    for (const p of platforms) {
+      if (!VALID_PLATFORMS.includes(p)) {
+        throw new CLIError(
+          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
+          ExitCode.VALIDATION_FAILED
+        );
+      }
+    }
+    try {
+      console.log("Generating slash commands...");
+      const slashResults = generateSlashCommands({
+        platforms,
+        global: opts.global,
+        includeGlobal: opts.includeGlobal,
+        output: opts.output,
+        skillsDir: "",
+        dryRun: opts.dryRun,
+        yes: opts.yes
+      });
+      for (const result of slashResults) {
+        const total = result.added.length + result.updated.length + result.unchanged.length;
+        console.log(
+          `  ${result.platform}: ${total} commands (${result.added.length} new, ${result.updated.length} updated)`
+        );
+      }
+      await handleOrphanDeletion(slashResults, { yes: opts.yes, dryRun: opts.dryRun });
+      console.log("\nGenerating agent definitions...");
+      const agentResults = generateAgentDefinitions({
+        platforms,
+        global: opts.global,
+        output: opts.output,
+        dryRun: opts.dryRun
+      });
+      for (const result of agentResults) {
+        const total = result.added.length + result.updated.length + result.unchanged.length;
+        console.log(
+          `  ${result.platform}: ${total} agents (${result.added.length} new, ${result.updated.length} updated)`
+        );
+      }
+      if (opts.dryRun) {
+        console.log("\n(dry run \u2014 no files written)");
+      } else {
+        console.log("\nDone.");
+      }
+      if (globalOpts.json) {
+        console.log(
+          JSON.stringify({ slashCommands: slashResults, agentDefinitions: agentResults }, null, 2)
+        );
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/graph/scan.ts
+import { Command as Command39 } from "commander";
+import * as path29 from "path";
+async function runScan(projectPath) {
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-M6BQODWC.js");
+  const store = new GraphStore();
+  const start = Date.now();
+  await new CodeIngestor(store).ingest(projectPath);
+  new TopologicalLinker(store).link();
+  const knowledgeIngestor = new KnowledgeIngestor(store);
+  await knowledgeIngestor.ingestAll(projectPath);
+  try {
+    await new GitIngestor(store).ingest(projectPath);
+  } catch {
+  }
+  const graphDir = path29.join(projectPath, ".harness", "graph");
+  await store.save(graphDir);
+  return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
+}
+function createScanCommand() {
+  return new Command39("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path29.resolve(inputPath);
+    const globalOpts = cmd.optsWithGlobals();
+    try {
+      const result = await runScan(projectPath);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result));
+      } else {
+        console.log(
+          `Graph built: ${result.nodeCount} nodes, ${result.edgeCount} edges (${result.durationMs}ms)`
+        );
+      }
+    } catch (err) {
+      console.error("Scan failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/ingest.ts
+import { Command as Command40 } from "commander";
+import * as path30 from "path";
+async function loadConnectorConfig(projectPath, source) {
+  try {
+    const fs23 = await import("fs/promises");
+    const configPath = path30.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs23.readFile(configPath, "utf-8"));
+    const connector = config.graph?.connectors?.find(
+      (c) => c.source === source
+    );
+    return connector?.config ?? {};
+  } catch {
+    return {};
+  }
+}
+function mergeResults(...results) {
+  return results.reduce(
+    (acc, r) => ({
+      nodesAdded: acc.nodesAdded + r.nodesAdded,
+      nodesUpdated: acc.nodesUpdated + r.nodesUpdated,
+      edgesAdded: acc.edgesAdded + r.edgesAdded,
+      edgesUpdated: acc.edgesUpdated + r.edgesUpdated,
+      errors: [...acc.errors, ...r.errors],
+      durationMs: acc.durationMs + r.durationMs
+    }),
+    {
+      nodesAdded: 0,
+      nodesUpdated: 0,
+      edgesAdded: 0,
+      edgesUpdated: 0,
+      errors: [],
+      durationMs: 0
+    }
+  );
+}
+async function runIngest(projectPath, source, opts) {
+  const {
+    GraphStore,
+    CodeIngestor,
+    TopologicalLinker,
+    KnowledgeIngestor,
+    GitIngestor,
+    SyncManager,
+    JiraConnector,
+    SlackConnector
+  } = await import("./dist-M6BQODWC.js");
+  const graphDir = path30.join(projectPath, ".harness", "graph");
+  const store = new GraphStore();
+  await store.load(graphDir);
+  if (opts?.all) {
+    const startMs = Date.now();
+    const codeResult = await new CodeIngestor(store).ingest(projectPath);
+    new TopologicalLinker(store).link();
+    const knowledgeResult = await new KnowledgeIngestor(store).ingestAll(projectPath);
+    const gitResult = await new GitIngestor(store).ingest(projectPath);
+    const syncManager = new SyncManager(store, graphDir);
+    const connectorMap = {
+      jira: () => new JiraConnector(),
+      slack: () => new SlackConnector()
+    };
+    for (const [name, factory] of Object.entries(connectorMap)) {
+      const config = await loadConnectorConfig(projectPath, name);
+      syncManager.registerConnector(factory(), config);
+    }
+    const connectorResult = await syncManager.syncAll();
+    await store.save(graphDir);
+    const merged = mergeResults(codeResult, knowledgeResult, gitResult, connectorResult);
+    return { ...merged, durationMs: Date.now() - startMs };
+  }
+  let result;
+  switch (source) {
+    case "code":
+      result = await new CodeIngestor(store).ingest(projectPath);
+      new TopologicalLinker(store).link();
+      break;
+    case "knowledge":
+      result = await new KnowledgeIngestor(store).ingestAll(projectPath);
+      break;
+    case "git":
+      result = await new GitIngestor(store).ingest(projectPath);
+      break;
+    default: {
+      const knownConnectors = ["jira", "slack"];
+      if (!knownConnectors.includes(source)) {
+        throw new Error(`Unknown source: ${source}. Available: code, knowledge, git, jira, slack`);
+      }
+      if (!SyncManager) {
+        throw new Error(
+          `Connector support not available. Ensure @harness-engineering/graph is built with connector support.`
+        );
+      }
+      const syncManager = new SyncManager(store, graphDir);
+      const extConnectorMap = {
+        jira: () => new JiraConnector(),
+        slack: () => new SlackConnector()
+      };
+      const factory = extConnectorMap[source];
+      const config = await loadConnectorConfig(projectPath, source);
+      syncManager.registerConnector(factory(), config);
+      result = await syncManager.sync(source);
+      break;
+    }
+  }
+  await store.save(graphDir);
+  return result;
+}
+function createIngestCommand() {
+  return new Command40("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
+    if (!opts.source && !opts.all) {
+      console.error("Error: --source or --all is required");
+      process.exit(1);
+    }
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path30.resolve(globalOpts.config ? path30.dirname(globalOpts.config) : ".");
+    try {
+      const result = await runIngest(projectPath, opts.source ?? "", {
+        full: opts.full,
+        all: opts.all
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result));
+      } else {
+        const label = opts.all ? "all" : opts.source;
+        console.log(
+          `Ingested (${label}): +${result.nodesAdded} nodes, +${result.edgesAdded} edges (${result.durationMs}ms)`
+        );
+      }
+    } catch (err) {
+      console.error("Ingest failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/query.ts
+import { Command as Command41 } from "commander";
+import * as path31 from "path";
+async function runQuery(projectPath, rootNodeId, opts) {
+  const { GraphStore, ContextQL } = await import("./dist-M6BQODWC.js");
+  const store = new GraphStore();
+  const graphDir = path31.join(projectPath, ".harness", "graph");
+  const loaded = await store.load(graphDir);
+  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
+  const params = {
+    rootNodeIds: [rootNodeId],
+    maxDepth: opts.depth ?? 3,
+    bidirectional: opts.bidirectional ?? false,
+    ...opts.types ? { includeTypes: opts.types.split(",") } : {},
+    ...opts.edges ? { includeEdges: opts.edges.split(",") } : {}
+  };
+  const cql = new ContextQL(store);
+  return cql.execute(params);
+}
+function createQueryCommand() {
+  return new Command41("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path31.resolve(globalOpts.config ? path31.dirname(globalOpts.config) : ".");
+    try {
+      const result = await runQuery(projectPath, rootNodeId, {
+        depth: parseInt(opts.depth),
+        types: opts.types,
+        edges: opts.edges,
+        bidirectional: opts.bidirectional
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(
+          `Found ${result.nodes.length} nodes, ${result.edges.length} edges (depth ${result.stats.depthReached}, pruned ${result.stats.pruned})`
+        );
+        for (const node of result.nodes) {
+          console.log(`  ${node.type.padEnd(12)} ${node.id}`);
+        }
+      }
+    } catch (err) {
+      console.error("Query failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/index.ts
+import { Command as Command42 } from "commander";
+
+// src/commands/graph/status.ts
+import * as path32 from "path";
+async function runGraphStatus(projectPath) {
+  const { GraphStore } = await import("./dist-M6BQODWC.js");
+  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const store = new GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
+  const fs23 = await import("fs/promises");
+  const metaPath = path32.join(graphDir, "metadata.json");
+  let lastScan = "unknown";
+  try {
+    const meta = JSON.parse(await fs23.readFile(metaPath, "utf-8"));
+    lastScan = meta.lastScanTimestamp;
+  } catch {
+  }
+  const allNodes = store.findNodes({});
+  const nodesByType = {};
+  for (const node of allNodes) {
+    nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+  }
+  let connectorSyncStatus = {};
+  try {
+    const syncMetaPath = path32.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs23.readFile(syncMetaPath, "utf-8"));
+    for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
+      connectorSyncStatus[name] = data.lastSyncTimestamp;
+    }
+  } catch {
+  }
+  return {
+    status: "ok",
+    nodeCount: store.nodeCount,
+    edgeCount: store.edgeCount,
+    nodesByType,
+    lastScanTimestamp: lastScan,
+    ...Object.keys(connectorSyncStatus).length > 0 ? { connectorSyncStatus } : {}
+  };
+}
+
+// src/commands/graph/export.ts
+import * as path33 from "path";
+async function runGraphExport(projectPath, format) {
+  const { GraphStore } = await import("./dist-M6BQODWC.js");
+  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const store = new GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
+  if (format === "json") {
+    const nodes = store.findNodes({});
+    const edges = store.getEdges({});
+    return JSON.stringify({ nodes, edges }, null, 2);
+  }
+  if (format === "mermaid") {
+    const nodes = store.findNodes({});
+    const edges = store.getEdges({});
+    const lines = ["graph TD"];
+    for (const node of nodes.slice(0, 200)) {
+      const safeId = node.id.replace(/[^a-zA-Z0-9]/g, "_");
+      const safeName = node.name.replace(/"/g, "#quot;");
+      lines.push(`  ${safeId}["${safeName}"]`);
+    }
+    for (const edge of edges.slice(0, 500)) {
+      const safeFrom = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
+      const safeTo = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
+      lines.push(`  ${safeFrom} -->|${edge.type}| ${safeTo}`);
     }
-    const { filename, content } = result.value;
-    const targetPath = path22.resolve(filename);
-    const dir = path22.dirname(targetPath);
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(targetPath, content);
-    if (platform === "generic" && process.platform !== "win32") {
-      fs10.chmodSync(targetPath, "755");
+    return lines.join("\n");
+  }
+  throw new Error(`Unknown format: ${format}. Available: json, mermaid`);
+}
+
+// src/commands/graph/index.ts
+import * as path34 from "path";
+function createGraphCommand() {
+  const graph = new Command42("graph").description("Knowledge graph management");
+  graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const projectPath = path34.resolve(globalOpts.config ? path34.dirname(globalOpts.config) : ".");
+      const result = await runGraphStatus(projectPath);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.status === "no_graph") {
+        console.log(result.message);
+      } else {
+        console.log(`Graph: ${result.nodeCount} nodes, ${result.edgeCount} edges`);
+        console.log(`Last scan: ${result.lastScanTimestamp}`);
+        console.log("Nodes by type:");
+        for (const [type, count] of Object.entries(result.nodesByType)) {
+          console.log(`  ${type}: ${count}`);
+        }
+        if (result.connectorSyncStatus) {
+          console.log("Connector sync status:");
+          for (const [name, timestamp] of Object.entries(result.connectorSyncStatus)) {
+            console.log(`  ${name}: last synced ${timestamp}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Status failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
     }
-    if (globalOpts.json) {
-      console.log(JSON.stringify({ file: filename, platform }));
-    } else {
-      logger.success(`Generated ${filename} for ${platform}`);
-      logger.dim("Run 'harness ci check' to test locally");
+  });
+  graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path34.resolve(globalOpts.config ? path34.dirname(globalOpts.config) : ".");
+    try {
+      const output = await runGraphExport(projectPath, opts.format);
+      console.log(output);
+    } catch (err) {
+      console.error("Export failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
     }
   });
+  return graph;
 }
 
-// src/commands/ci/index.ts
-function createCICommand() {
-  const command = new Command33("ci").description("CI/CD integration commands");
-  command.addCommand(createCheckCommand());
-  command.addCommand(createInitCommand2());
-  return command;
+// src/commands/mcp.ts
+import { Command as Command43 } from "commander";
+function createMcpCommand() {
+  return new Command43("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
+    const { startServer: startServer2 } = await import("./mcp-YM6QLHLZ.js");
+    await startServer2();
+  });
 }
 
-// src/commands/update.ts
-import { Command as Command34 } from "commander";
-import { execFileSync as execFileSync3 } from "child_process";
-import { realpathSync } from "fs";
-import readline2 from "readline";
-import chalk3 from "chalk";
-function detectPackageManager() {
+// src/commands/impact-preview.ts
+import { Command as Command44 } from "commander";
+import { execSync as execSync3 } from "child_process";
+import * as path35 from "path";
+import * as fs17 from "fs";
+function getStagedFiles(cwd) {
   try {
-    const argv1 = process.argv[1];
-    if (!argv1) return "npm";
-    const binPath = realpathSync(argv1);
-    const normalizedBin = binPath.replace(/\\/g, "/");
-    if (normalizedBin.includes("pnpm/global/") || // eslint-disable-line @harness-engineering/no-hardcoded-path-separator -- platform-safe
-    normalizedBin.includes("pnpm-global/")) {
-      return "pnpm";
-    }
-    if (normalizedBin.includes(".yarn/")) {
-      return "yarn";
-    }
+    const output = execSync3("git diff --cached --name-only", {
+      cwd,
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter((f) => f.length > 0);
   } catch {
+    return [];
   }
-  return "npm";
-}
-function getLatestVersion(pkg = "@harness-engineering/cli") {
-  const output = execFileSync3("npm", ["view", pkg, "dist-tags.latest"], {
-    encoding: "utf-8",
-    timeout: 15e3
-  });
-  return output.trim();
 }
-function getInstalledVersion(pm) {
+function graphExists(projectPath) {
   try {
-    const output = execFileSync3(pm, ["list", "-g", "@harness-engineering/cli", "--json"], {
-      encoding: "utf-8",
-      timeout: 15e3
-    });
-    const data = JSON.parse(output);
-    const deps = data.dependencies ?? {};
-    return deps["@harness-engineering/cli"]?.version ?? null;
+    return fs17.existsSync(path35.join(projectPath, ".harness", "graph", "graph.json"));
   } catch {
-    return null;
+    return false;
   }
 }
-function getInstalledPackages(pm) {
+function extractNodeName(id) {
+  const parts = id.split(":");
+  if (parts.length > 1) {
+    const fullPath = parts.slice(1).join(":");
+    return path35.basename(fullPath);
+  }
+  return id;
+}
+var TEST_NODE_TYPES = /* @__PURE__ */ new Set(["test_result"]);
+var DOC_NODE_TYPES = /* @__PURE__ */ new Set(["adr", "decision", "document", "learning"]);
+function parseImpactResponse(response) {
+  if (response.isError) return null;
+  const text = response.content[0]?.text;
+  if (!text) return null;
   try {
-    const output = execFileSync3(pm, ["list", "-g", "--json"], {
-      encoding: "utf-8",
-      timeout: 15e3
-    });
-    const data = JSON.parse(output);
-    const deps = data.dependencies ?? {};
-    return Object.keys(deps).filter((name) => name.startsWith("@harness-engineering/"));
+    const data = JSON.parse(text);
+    if (data.mode === "summary") {
+      const items = { code: [], tests: [], docs: [], other: [] };
+      for (const item of data.highestRiskItems ?? []) {
+        if (TEST_NODE_TYPES.has(item.type)) items.tests.push(item);
+        else if (DOC_NODE_TYPES.has(item.type)) items.docs.push(item);
+        else items.code.push(item);
+      }
+      return { counts: data.impactCounts, items };
+    } else {
+      const impact = data.impact ?? {};
+      const items = {
+        code: (impact.code ?? []).map((n) => ({
+          id: n.id,
+          type: n.type
+        })),
+        tests: (impact.tests ?? []).map((n) => ({
+          id: n.id,
+          type: n.type
+        })),
+        docs: (impact.docs ?? []).map((n) => ({
+          id: n.id,
+          type: n.type
+        })),
+        other: (impact.other ?? []).map((n) => ({
+          id: n.id,
+          type: n.type
+        }))
+      };
+      return {
+        counts: {
+          code: items.code.length,
+          tests: items.tests.length,
+          docs: items.docs.length,
+          other: items.other.length
+        },
+        items
+      };
+    }
   } catch {
-    return ["@harness-engineering/cli", "@harness-engineering/core"];
+    return null;
   }
 }
-function prompt(question) {
-  const rl = readline2.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve20) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve20(answer.trim().toLowerCase());
-    });
-  });
-}
-function createUpdateCommand() {
-  return new Command34("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const pm = detectPackageManager();
-    if (globalOpts.verbose) {
-      logger.info(`Detected package manager: ${pm}`);
-    }
-    const currentVersion = getInstalledVersion(pm);
-    let latestCliVersion;
-    if (!opts.version) {
-      logger.info("Checking for updates...");
-      try {
-        latestCliVersion = getLatestVersion();
-      } catch {
-        logger.error("Failed to fetch latest version from npm registry");
-        return process.exit(ExitCode.ERROR);
-      }
-      if (currentVersion && currentVersion === latestCliVersion) {
-        logger.success(`Already up to date (v${currentVersion})`);
-        process.exit(ExitCode.SUCCESS);
-      }
-      if (currentVersion) {
-        console.log("");
-        logger.info(`Current CLI version: ${chalk3.dim(`v${currentVersion}`)}`);
-        logger.info(`Latest CLI version:  ${chalk3.green(`v${latestCliVersion}`)}`);
-        console.log("");
+function mergeImpactGroups(groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = { code: [], tests: [], docs: [], other: [] };
+  for (const group of groups) {
+    for (const category of ["code", "tests", "docs", "other"]) {
+      for (const item of group[category]) {
+        if (!seen.has(item.id)) {
+          seen.add(item.id);
+          merged[category].push(item);
+        }
       }
     }
-    const packages = getInstalledPackages(pm);
-    if (globalOpts.verbose) {
-      logger.info(`Installed packages: ${packages.join(", ")}`);
+  }
+  return merged;
+}
+function formatCompactLine(label, count, unit, items, maxItems) {
+  if (count === 0) return "";
+  const labelPad = label.padEnd(6);
+  const countStr = String(count).padStart(3);
+  const topNames = items.slice(0, maxItems).map((i) => extractNodeName(i.id));
+  const remaining = count - topNames.length;
+  const namePart = remaining > 0 ? `(${topNames.join(", ")}, +${remaining})` : topNames.length > 0 ? `(${topNames.join(", ")})` : "";
+  return `  ${labelPad}${countStr} ${unit.padEnd(7)} ${namePart}`;
+}
+function formatCompact(stagedCount, merged, counts) {
+  const lines = [];
+  lines.push(`Impact Preview (${stagedCount} staged file${stagedCount === 1 ? "" : "s"})`);
+  const codeLine = formatCompactLine("Code:", counts.code, "files", merged.code, 2);
+  const testsLine = formatCompactLine("Tests:", counts.tests, "tests", merged.tests, 2);
+  const docsLine = formatCompactLine("Docs:", counts.docs, "docs", merged.docs, 2);
+  if (codeLine) lines.push(codeLine);
+  if (testsLine) lines.push(testsLine);
+  if (docsLine) lines.push(docsLine);
+  const total = counts.code + counts.tests + counts.docs + counts.other;
+  lines.push(`  Total: ${total} affected`);
+  return lines.join("\n");
+}
+function formatDetailed(stagedCount, merged, counts) {
+  const lines = [];
+  lines.push(`Impact Preview (${stagedCount} staged file${stagedCount === 1 ? "" : "s"})`);
+  const sections = [
+    { label: "Code", count: counts.code, unit: "files", items: merged.code },
+    { label: "Tests", count: counts.tests, unit: "tests", items: merged.tests },
+    { label: "Docs", count: counts.docs, unit: "docs", items: merged.docs }
+  ];
+  for (const section of sections) {
+    if (section.count === 0 && section.items.length === 0) continue;
+    lines.push(`  ${section.label}: ${section.count} ${section.unit}`);
+    for (const item of section.items) {
+      lines.push(`    ${extractNodeName(item.id)}`);
     }
-    const installPkgs = packages.map((pkg) => {
-      if (opts.version && pkg === "@harness-engineering/cli") {
-        return `${pkg}@${opts.version}`;
-      }
-      return `${pkg}@latest`;
+  }
+  const total = counts.code + counts.tests + counts.docs + counts.other;
+  lines.push(`  Total: ${total} affected`);
+  return lines.join("\n");
+}
+function formatPerFile(perFileResults) {
+  const lines = [];
+  lines.push(
+    `Impact Preview (${perFileResults.length} staged file${perFileResults.length === 1 ? "" : "s"})`
+  );
+  const maxLen = Math.max(...perFileResults.map((r) => r.file.length));
+  for (const result of perFileResults) {
+    const padded = result.file.padEnd(maxLen);
+    lines.push(`  ${padded}  -> ${result.code} files, ${result.tests} tests, ${result.docs} docs`);
+  }
+  return lines.join("\n");
+}
+async function runImpactPreview(options) {
+  const projectPath = path35.resolve(options.path ?? process.cwd());
+  const stagedFiles = getStagedFiles(projectPath);
+  if (stagedFiles.length === 0) {
+    return "Impact Preview: no staged changes";
+  }
+  if (!graphExists(projectPath)) {
+    return "Impact Preview: skipped (no graph \u2014 run `harness scan` to enable)";
+  }
+  const mode = options.detailed ? "detailed" : "summary";
+  const perFileResults = [];
+  const allGroups = [];
+  const aggregateCounts = { code: 0, tests: 0, docs: 0, other: 0 };
+  for (const file of stagedFiles) {
+    const response = await handleGetImpact({
+      path: projectPath,
+      filePath: file,
+      mode: options.perFile ? "summary" : mode
     });
-    const installCmd = `${pm} install -g ${installPkgs.join(" ")}`;
-    if (globalOpts.verbose) {
-      logger.info(`Running: ${installCmd}`);
-    }
-    try {
-      logger.info("Updating packages...");
-      execFileSync3(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
-      console.log("");
-      logger.success("Update complete");
-    } catch {
-      console.log("");
-      logger.error("Update failed. You can try manually:");
-      console.log(`  ${chalk3.cyan(installCmd)}`);
-      process.exit(ExitCode.ERROR);
+    const parsed = parseImpactResponse(response);
+    if (!parsed) continue;
+    aggregateCounts.code += parsed.counts.code;
+    aggregateCounts.tests += parsed.counts.tests;
+    aggregateCounts.docs += parsed.counts.docs;
+    aggregateCounts.other += parsed.counts.other;
+    if (options.perFile) {
+      perFileResults.push({
+        file,
+        code: parsed.counts.code,
+        tests: parsed.counts.tests,
+        docs: parsed.counts.docs
+      });
     }
-    console.log("");
-    const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (y/N) ");
-    if (regenAnswer === "y" || regenAnswer === "yes") {
-      const scopeAnswer = await prompt("Generate for (g)lobal or (l)ocal project? (g/l) ");
-      const isGlobal = scopeAnswer === "g" || scopeAnswer === "global";
-      try {
-        execFileSync3("harness", ["generate", ...isGlobal ? ["--global"] : []], {
-          stdio: "inherit"
-        });
-      } catch {
-        logger.warn("Generation failed. Run manually:");
-        console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
-      }
+    allGroups.push(parsed.items);
+  }
+  if (options.perFile) {
+    if (perFileResults.length === 0) {
+      return `Impact Preview (${stagedFiles.length} staged file${stagedFiles.length === 1 ? "" : "s"}): no impact data`;
     }
-    process.exit(ExitCode.SUCCESS);
+    return formatPerFile(perFileResults);
+  }
+  const merged = mergeImpactGroups(allGroups);
+  if (options.detailed) {
+    return formatDetailed(stagedFiles.length, merged, aggregateCounts);
+  }
+  return formatCompact(stagedFiles.length, merged, aggregateCounts);
+}
+function createImpactPreviewCommand() {
+  const command = new Command44("impact-preview").description("Show blast radius of staged changes using the knowledge graph").option("--detailed", "Show all affected files instead of top items").option("--per-file", "Show impact per staged file instead of aggregate").option("--path <dir>", "Project root (default: cwd)").action(async (opts) => {
+    const output = await runImpactPreview({
+      detailed: opts.detailed,
+      perFile: opts.perFile,
+      path: opts.path
+    });
+    console.log(output);
+    process.exit(0);
   });
+  return command;
 }
 
-// src/commands/generate.ts
-import { Command as Command35 } from "commander";
-function createGenerateCommand3() {
-  return new Command35("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const platforms = opts.platforms.split(",").map((p) => p.trim());
-    for (const p of platforms) {
-      if (!VALID_PLATFORMS.includes(p)) {
-        throw new CLIError(
-          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
-          ExitCode.VALIDATION_FAILED
-        );
+// src/commands/check-arch.ts
+import { Command as Command45 } from "commander";
+import { execSync as execSync4 } from "child_process";
+function getCommitHash(cwd) {
+  try {
+    return execSync4("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
+  } catch {
+    return "unknown";
+  }
+}
+function filterByModule(results, modulePath) {
+  const normalized = modulePath.replace(/\/+$/, "");
+  return results.filter((r) => r.scope === normalized || r.scope.startsWith(normalized + "/"));
+}
+function findThresholdViolations(results) {
+  const violations = [];
+  for (const result of results) {
+    for (const v of result.violations) {
+      if (v.severity === "error") {
+        violations.push(v);
       }
     }
-    try {
-      console.log("Generating slash commands...");
-      const slashResults = generateSlashCommands({
-        platforms,
-        global: opts.global,
-        includeGlobal: opts.includeGlobal,
-        output: opts.output,
-        skillsDir: "",
-        dryRun: opts.dryRun,
-        yes: opts.yes
-      });
-      for (const result of slashResults) {
-        const total = result.added.length + result.updated.length + result.unchanged.length;
-        console.log(
-          `  ${result.platform}: ${total} commands (${result.added.length} new, ${result.updated.length} updated)`
-        );
-      }
-      await handleOrphanDeletion(slashResults, { yes: opts.yes, dryRun: opts.dryRun });
-      console.log("\nGenerating agent definitions...");
-      const agentResults = generateAgentDefinitions({
-        platforms,
-        global: opts.global,
-        output: opts.output,
-        dryRun: opts.dryRun
-      });
-      for (const result of agentResults) {
-        const total = result.added.length + result.updated.length + result.unchanged.length;
-        console.log(
-          `  ${result.platform}: ${total} agents (${result.added.length} new, ${result.updated.length} updated)`
-        );
+  }
+  return violations;
+}
+async function runCheckArch(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const config = configResult.value;
+  const archConfig = config.architecture ?? ArchConfigSchema.parse({});
+  if (!archConfig.enabled) {
+    return Ok({
+      passed: true,
+      mode: "threshold-only",
+      totalViolations: 0,
+      newViolations: [],
+      resolvedViolations: [],
+      preExisting: [],
+      regressions: [],
+      thresholdViolations: []
+    });
+  }
+  let results = await runAll(archConfig, cwd);
+  if (options.module) {
+    results = filterByModule(results, options.module);
+  }
+  const manager = new ArchBaselineManager(cwd, archConfig.baselinePath);
+  if (options.updateBaseline) {
+    const commitHash = getCommitHash(cwd);
+    const baseline2 = manager.capture(results, commitHash);
+    manager.save(baseline2);
+    return Ok({
+      passed: true,
+      mode: "baseline",
+      totalViolations: 0,
+      newViolations: [],
+      resolvedViolations: [],
+      preExisting: [],
+      regressions: [],
+      thresholdViolations: [],
+      baselineUpdated: true
+    });
+  }
+  const thresholdViolations = findThresholdViolations(results);
+  const baseline = manager.load();
+  if (!baseline) {
+    const passed2 = thresholdViolations.length === 0;
+    return Ok({
+      passed: passed2,
+      mode: "threshold-only",
+      totalViolations: thresholdViolations.length,
+      newViolations: [],
+      resolvedViolations: [],
+      preExisting: [],
+      regressions: [],
+      thresholdViolations,
+      warning: "No baseline found. Running in threshold-only mode. Run with --update-baseline to capture current state."
+    });
+  }
+  const diffResult = diff(results, baseline);
+  const passed = diffResult.passed && thresholdViolations.length === 0;
+  return Ok({
+    passed,
+    mode: "baseline",
+    totalViolations: diffResult.newViolations.length + thresholdViolations.length,
+    newViolations: diffResult.newViolations,
+    resolvedViolations: diffResult.resolvedViolations,
+    preExisting: diffResult.preExisting,
+    regressions: diffResult.regressions,
+    thresholdViolations
+  });
+}
+function createCheckArchCommand() {
+  const command = new Command45("check-arch").description("Check architecture assertions against baseline and thresholds").option("--update-baseline", "Capture current state as new baseline").option("--module <path>", "Check a single module").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckArch({
+      configPath: globalOpts.config,
+      updateBaseline: opts.updateBaseline,
+      json: globalOpts.json,
+      module: opts.module
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
       }
-      if (opts.dryRun) {
-        console.log("\n(dry run \u2014 no files written)");
+      process.exit(result.error.exitCode);
+    }
+    const value = result.value;
+    if (value.warning && mode !== OutputMode.JSON) {
+      logger.warn(value.warning);
+    }
+    if (value.baselineUpdated) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ baselineUpdated: true }));
       } else {
-        console.log("\nDone.");
+        logger.success("Baseline updated successfully.");
       }
-      if (globalOpts.json) {
-        console.log(
-          JSON.stringify({ slashCommands: slashResults, agentDefinitions: agentResults }, null, 2)
+      process.exit(ExitCode.SUCCESS);
+      return;
+    }
+    const issues = [
+      ...value.newViolations.map((v) => ({
+        file: v.file,
+        message: `New violation [${v.severity}]: ${v.detail}`
+      })),
+      ...value.thresholdViolations.map((v) => ({
+        file: v.file,
+        message: `Threshold exceeded: ${v.detail}`
+      })),
+      ...value.regressions.map((r) => ({
+        message: `Regression in ${r.category}: ${r.baselineValue} -> ${r.currentValue} (+${r.delta})`
+      }))
+    ];
+    if (mode === OutputMode.JSON) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      if (value.resolvedViolations.length > 0 && mode !== OutputMode.QUIET) {
+        logger.success(
+          `${value.resolvedViolations.length} violation(s) resolved since baseline.`
         );
       }
-    } catch (error) {
-      handleError(error);
+      const output = formatter.formatValidation({
+        valid: value.passed,
+        issues
+      });
+      if (output) {
+        console.log(output);
+      }
     }
+    process.exit(value.passed ? ExitCode.SUCCESS : ExitCode.VALIDATION_FAILED);
   });
+  return command;
 }
 
-// src/commands/graph/scan.ts
-import { Command as Command36 } from "commander";
-import * as path23 from "path";
-async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-I7DB5VKB.js");
-  const store = new GraphStore();
-  const start = Date.now();
-  await new CodeIngestor(store).ingest(projectPath);
-  new TopologicalLinker(store).link();
-  const knowledgeIngestor = new KnowledgeIngestor(store);
-  await knowledgeIngestor.ingestAll(projectPath);
-  try {
-    await new GitIngestor(store).ingest(projectPath);
-  } catch {
-  }
-  const graphDir = path23.join(projectPath, ".harness", "graph");
-  await store.save(graphDir);
-  return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
+// src/commands/blueprint.ts
+import { Command as Command46 } from "commander";
+import * as path36 from "path";
+function createBlueprintCommand() {
+  return new Command46("blueprint").description("Generate a self-contained, interactive blueprint of the codebase").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory", "docs/blueprint").action(async (projectPath, options) => {
+    try {
+      const rootDir = path36.resolve(projectPath);
+      const outputDir = path36.resolve(options.output);
+      logger.info(`Scanning project at ${rootDir}...`);
+      const scanner = new ProjectScanner(rootDir);
+      const data = await scanner.scan();
+      logger.info(`Generating blueprint to ${outputDir}...`);
+      const generator = new BlueprintGenerator();
+      await generator.generate(data, { outputDir });
+      logger.success(`Blueprint generated successfully at ${path36.join(outputDir, "index.html")}`);
+    } catch (error) {
+      logger.error(
+        `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  });
 }
-function createScanCommand() {
-  return new Command36("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
-    const projectPath = path23.resolve(inputPath);
-    const globalOpts = cmd.optsWithGlobals();
+
+// src/commands/share.ts
+import { Command as Command47 } from "commander";
+import * as fs18 from "fs";
+import * as path37 from "path";
+import { parse as parseYaml } from "yaml";
+var MANIFEST_FILENAME = "constraints.yaml";
+function createShareCommand() {
+  return new Command47("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
+    const rootDir = path37.resolve(projectPath);
+    const manifestPath = path37.join(rootDir, MANIFEST_FILENAME);
+    if (!fs18.existsSync(manifestPath)) {
+      logger.error(
+        `No ${MANIFEST_FILENAME} found at ${manifestPath}.
+Create a constraints.yaml in your project root to define what to share.`
+      );
+      process.exit(1);
+    }
+    let parsed;
     try {
-      const result = await runScan(projectPath);
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result));
-      } else {
-        console.log(
-          `Graph built: ${result.nodeCount} nodes, ${result.edgeCount} edges (${result.durationMs}ms)`
-        );
-      }
+      const raw = fs18.readFileSync(manifestPath, "utf-8");
+      parsed = parseYaml(raw);
     } catch (err) {
-      console.error("Scan failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
+      logger.error(
+        `Failed to read ${MANIFEST_FILENAME}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    const manifestResult = parseManifest(parsed);
+    if (!manifestResult.ok) {
+      logger.error(`Invalid ${MANIFEST_FILENAME}: ${manifestResult.error}`);
+      process.exit(1);
+    }
+    const manifest = manifestResult.value;
+    const configResult = resolveConfig(path37.join(rootDir, "harness.config.json"));
+    if (!configResult.ok) {
+      logger.error(configResult.error.message);
+      process.exit(1);
     }
+    const config = configResult.value;
+    const bundleResult = extractBundle(manifest, config);
+    if (!bundleResult.ok) {
+      logger.error(`Failed to extract bundle: ${bundleResult.error}`);
+      process.exit(1);
+    }
+    const bundle = bundleResult.value;
+    if (Object.keys(bundle.constraints).length === 0) {
+      logger.error(
+        "No constraints found for the include paths in constraints.yaml.\nCheck that your harness config contains the declared sections."
+      );
+      process.exit(1);
+    }
+    const outputDir = path37.resolve(options.output);
+    const outputPath = path37.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}`);
+      process.exit(1);
+    }
+    logger.success(`Bundle written to ${outputPath}`);
   });
 }
 
-// src/commands/graph/ingest.ts
-import { Command as Command37 } from "commander";
-import * as path24 from "path";
-async function loadConnectorConfig(projectPath, source) {
+// src/commands/install.ts
+import * as fs20 from "fs";
+import * as path39 from "path";
+import { Command as Command48 } from "commander";
+import { parse as yamlParse } from "yaml";
+
+// src/registry/tarball.ts
+import * as fs19 from "fs";
+import * as path38 from "path";
+import * as os3 from "os";
+import { execFileSync as execFileSync5 } from "child_process";
+function extractTarball(tarballBuffer) {
+  const tmpDir = fs19.mkdtempSync(path38.join(os3.tmpdir(), "harness-skill-install-"));
+  const tarballPath = path38.join(tmpDir, "package.tgz");
   try {
-    const fs11 = await import("fs/promises");
-    const configPath = path24.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs11.readFile(configPath, "utf-8"));
-    const connector = config.graph?.connectors?.find(
-      (c) => c.source === source
+    fs19.writeFileSync(tarballPath, tarballBuffer);
+    execFileSync5("tar", ["-xzf", tarballPath, "-C", tmpDir], {
+      timeout: 3e4
+    });
+    fs19.unlinkSync(tarballPath);
+  } catch (err) {
+    cleanupTempDir(tmpDir);
+    throw new Error(
+      `Failed to extract tarball: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
     );
-    return connector?.config ?? {};
-  } catch {
-    return {};
   }
+  return tmpDir;
 }
-function mergeResults(...results) {
-  return results.reduce(
-    (acc, r) => ({
-      nodesAdded: acc.nodesAdded + r.nodesAdded,
-      nodesUpdated: acc.nodesUpdated + r.nodesUpdated,
-      edgesAdded: acc.edgesAdded + r.edgesAdded,
-      edgesUpdated: acc.edgesUpdated + r.edgesUpdated,
-      errors: [...acc.errors, ...r.errors],
-      durationMs: acc.durationMs + r.durationMs
-    }),
-    {
-      nodesAdded: 0,
-      nodesUpdated: 0,
-      edgesAdded: 0,
-      edgesUpdated: 0,
-      errors: [],
-      durationMs: 0
+function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
+  const files = fs19.readdirSync(extractedPkgDir);
+  for (const platform of platforms) {
+    const targetDir = path38.join(communityBaseDir, platform, skillName);
+    if (fs19.existsSync(targetDir)) {
+      fs19.rmSync(targetDir, { recursive: true, force: true });
     }
-  );
+    fs19.mkdirSync(targetDir, { recursive: true });
+    for (const file of files) {
+      if (file === "package.json" || file === "node_modules") continue;
+      const srcPath = path38.join(extractedPkgDir, file);
+      const destPath = path38.join(targetDir, file);
+      const stat = fs19.statSync(srcPath);
+      if (stat.isDirectory()) {
+        fs19.cpSync(srcPath, destPath, { recursive: true });
+      } else {
+        fs19.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
 }
-async function runIngest(projectPath, source, opts) {
-  const {
-    GraphStore,
-    CodeIngestor,
-    TopologicalLinker,
-    KnowledgeIngestor,
-    GitIngestor,
-    SyncManager,
-    JiraConnector,
-    SlackConnector
-  } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path24.join(projectPath, ".harness", "graph");
-  const store = new GraphStore();
-  await store.load(graphDir);
-  if (opts?.all) {
-    const startMs = Date.now();
-    const codeResult = await new CodeIngestor(store).ingest(projectPath);
-    new TopologicalLinker(store).link();
-    const knowledgeResult = await new KnowledgeIngestor(store).ingestAll(projectPath);
-    const gitResult = await new GitIngestor(store).ingest(projectPath);
-    const syncManager = new SyncManager(store, graphDir);
-    const connectorMap = {
-      jira: () => new JiraConnector(),
-      slack: () => new SlackConnector()
-    };
-    for (const [name, factory] of Object.entries(connectorMap)) {
-      const config = await loadConnectorConfig(projectPath, name);
-      syncManager.registerConnector(factory(), config);
+function removeSkillContent(communityBaseDir, skillName, platforms) {
+  for (const platform of platforms) {
+    const targetDir = path38.join(communityBaseDir, platform, skillName);
+    if (fs19.existsSync(targetDir)) {
+      fs19.rmSync(targetDir, { recursive: true, force: true });
     }
-    const connectorResult = await syncManager.syncAll();
-    await store.save(graphDir);
-    const merged = mergeResults(codeResult, knowledgeResult, gitResult, connectorResult);
-    return { ...merged, durationMs: Date.now() - startMs };
   }
-  let result;
-  switch (source) {
-    case "code":
-      result = await new CodeIngestor(store).ingest(projectPath);
-      new TopologicalLinker(store).link();
-      break;
-    case "knowledge":
-      result = await new KnowledgeIngestor(store).ingestAll(projectPath);
-      break;
-    case "git":
-      result = await new GitIngestor(store).ingest(projectPath);
-      break;
-    default: {
-      const knownConnectors = ["jira", "slack"];
-      if (!knownConnectors.includes(source)) {
-        throw new Error(`Unknown source: ${source}. Available: code, knowledge, git, jira, slack`);
-      }
-      if (!SyncManager) {
-        throw new Error(
-          `Connector support not available. Ensure @harness-engineering/graph is built with connector support.`
-        );
-      }
-      const syncManager = new SyncManager(store, graphDir);
-      const extConnectorMap = {
-        jira: () => new JiraConnector(),
-        slack: () => new SlackConnector()
-      };
-      const factory = extConnectorMap[source];
-      const config = await loadConnectorConfig(projectPath, source);
-      syncManager.registerConnector(factory(), config);
-      result = await syncManager.sync(source);
-      break;
+}
+function cleanupTempDir(dirPath) {
+  try {
+    fs19.rmSync(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/registry/resolver.ts
+import semver2 from "semver";
+function resolveVersion(metadata, versionRange) {
+  const versions = Object.keys(metadata.versions);
+  if (versions.length === 0) {
+    throw new Error(`No versions available for ${metadata.name}.`);
+  }
+  if (!versionRange) {
+    const latestTag = metadata["dist-tags"].latest;
+    if (latestTag) {
+      const latestInfo = metadata.versions[latestTag];
+      if (latestInfo) return latestInfo;
     }
+    const highest = semver2.maxSatisfying(versions, "*");
+    if (!highest || !metadata.versions[highest]) {
+      throw new Error(`No versions available for ${metadata.name}.`);
+    }
+    return metadata.versions[highest];
   }
-  await store.save(graphDir);
-  return result;
+  const matched = semver2.maxSatisfying(versions, versionRange);
+  if (!matched || !metadata.versions[matched]) {
+    throw new Error(
+      `No version of ${metadata.name} matches range ${versionRange}. Available: ${versions.join(", ")}`
+    );
+  }
+  return metadata.versions[matched];
 }
-function createIngestCommand() {
-  return new Command37("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
-    if (!opts.source && !opts.all) {
-      console.error("Error: --source or --all is required");
-      process.exit(1);
+function findDependentsOf(lockfile, targetPackageName) {
+  const dependents = [];
+  const targetEntry = lockfile.skills[targetPackageName];
+  if (targetEntry?.dependencyOf) {
+    dependents.push(targetEntry.dependencyOf);
+  }
+  return dependents;
+}
+
+// src/commands/install.ts
+function validateSkillYaml(parsed) {
+  const result = SkillMetadataSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new Error(`contains invalid skill.yaml: ${issues}`);
+  }
+  return {
+    name: result.data.name,
+    version: result.data.version,
+    platforms: result.data.platforms,
+    depends_on: result.data.depends_on ?? []
+  };
+}
+async function runLocalInstall(fromPath, options) {
+  const resolvedPath = path39.resolve(fromPath);
+  if (!fs20.existsSync(resolvedPath)) {
+    throw new Error(`--from path does not exist: ${resolvedPath}`);
+  }
+  const stat = fs20.statSync(resolvedPath);
+  let extractDir = null;
+  let pkgDir;
+  if (stat.isDirectory()) {
+    pkgDir = resolvedPath;
+  } else if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
+    const tarballBuffer = fs20.readFileSync(resolvedPath);
+    extractDir = extractTarball(tarballBuffer);
+    pkgDir = path39.join(extractDir, "package");
+  } else {
+    throw new Error(`--from path must be a directory or .tgz file. Got: ${resolvedPath}`);
+  }
+  try {
+    const skillYamlPath = path39.join(pkgDir, "skill.yaml");
+    if (!fs20.existsSync(skillYamlPath)) {
+      throw new Error(`No skill.yaml found at ${skillYamlPath}`);
     }
-    const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path24.resolve(globalOpts.config ? path24.dirname(globalOpts.config) : ".");
-    try {
-      const result = await runIngest(projectPath, opts.source ?? "", {
-        full: opts.full,
-        all: opts.all
-      });
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result));
-      } else {
-        const label = opts.all ? "all" : opts.source;
-        console.log(
-          `Ingested (${label}): +${result.nodesAdded} nodes, +${result.edgesAdded} edges (${result.durationMs}ms)`
-        );
-      }
-    } catch (err) {
-      console.error("Ingest failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
+    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const parsed = yamlParse(rawYaml);
+    const skillYaml = validateSkillYaml(parsed);
+    const shortName = skillYaml.name;
+    const globalDir = resolveGlobalSkillsDir();
+    const skillsDir = path39.dirname(globalDir);
+    const communityBase = path39.join(skillsDir, "community");
+    const lockfilePath = path39.join(communityBase, "skills-lock.json");
+    const bundledNames = getBundledSkillNames(globalDir);
+    if (bundledNames.has(shortName)) {
+      throw new Error(
+        `'${shortName}' is a bundled skill and cannot be overridden by community installs.`
+      );
+    }
+    placeSkillContent(pkgDir, communityBase, shortName, skillYaml.platforms);
+    const packageName = `@harness-skills/${shortName}`;
+    const lockfile = readLockfile2(lockfilePath);
+    const entry = {
+      version: skillYaml.version,
+      resolved: `local:${resolvedPath}`,
+      integrity: "",
+      platforms: skillYaml.platforms,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dependencyOf: options._dependencyOf ?? null
+    };
+    const updatedLockfile = updateLockfileEntry(lockfile, packageName, entry);
+    writeLockfile2(lockfilePath, updatedLockfile);
+    return {
+      installed: true,
+      name: packageName,
+      version: skillYaml.version
+    };
+  } finally {
+    if (extractDir) {
+      cleanupTempDir(extractDir);
+    }
+  }
+}
+async function runInstall(skillName, options) {
+  if (options.from && options.registry) {
+    throw new Error("--from and --registry cannot be used together");
+  }
+  if (options.from) {
+    return runLocalInstall(options.from, options);
+  }
+  const packageName = resolvePackageName(skillName);
+  const shortName = extractSkillName(packageName);
+  const globalDir = resolveGlobalSkillsDir();
+  const skillsDir = path39.dirname(globalDir);
+  const communityBase = path39.join(skillsDir, "community");
+  const lockfilePath = path39.join(communityBase, "skills-lock.json");
+  const bundledNames = getBundledSkillNames(globalDir);
+  if (bundledNames.has(shortName)) {
+    throw new Error(
+      `'${shortName}' is a bundled skill and cannot be overridden by community installs.`
+    );
+  }
+  const metadata = await fetchPackageMetadata(packageName, options.registry);
+  const versionInfo = resolveVersion(metadata, options.version);
+  const resolvedVersion = versionInfo.version;
+  const lockfile = readLockfile2(lockfilePath);
+  const existingEntry = lockfile.skills[packageName];
+  const previousVersion = existingEntry?.version;
+  if (existingEntry && existingEntry.version === resolvedVersion && !options.force) {
+    return {
+      installed: false,
+      skipped: true,
+      name: packageName,
+      version: resolvedVersion
+    };
+  }
+  const authToken = options.registry ? readNpmrcToken(options.registry) ?? void 0 : void 0;
+  const tarballBuffer = await downloadTarball(versionInfo.dist.tarball, authToken);
+  const extractDir = extractTarball(tarballBuffer);
+  let skillYaml;
+  try {
+    const extractedPkgDir = path39.join(extractDir, "package");
+    const skillYamlPath = path39.join(extractedPkgDir, "skill.yaml");
+    if (!fs20.existsSync(skillYamlPath)) {
+      throw new Error(`contains invalid skill.yaml: file not found in package`);
     }
-  });
-}
-
-// src/commands/graph/query.ts
-import { Command as Command38 } from "commander";
-import * as path25 from "path";
-async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-I7DB5VKB.js");
-  const store = new GraphStore();
-  const graphDir = path25.join(projectPath, ".harness", "graph");
-  const loaded = await store.load(graphDir);
-  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
-  const params = {
-    rootNodeIds: [rootNodeId],
-    maxDepth: opts.depth ?? 3,
-    bidirectional: opts.bidirectional ?? false,
-    ...opts.types ? { includeTypes: opts.types.split(",") } : {},
-    ...opts.edges ? { includeEdges: opts.edges.split(",") } : {}
+    const rawYaml = fs20.readFileSync(skillYamlPath, "utf-8");
+    const parsed = yamlParse(rawYaml);
+    skillYaml = validateSkillYaml(parsed);
+    placeSkillContent(extractedPkgDir, communityBase, shortName, skillYaml.platforms);
+  } catch (err) {
+    cleanupTempDir(extractDir);
+    throw err;
+  }
+  cleanupTempDir(extractDir);
+  const entry = {
+    version: resolvedVersion,
+    resolved: versionInfo.dist.tarball,
+    integrity: versionInfo.dist.integrity,
+    platforms: skillYaml.platforms,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dependencyOf: options._dependencyOf ?? null
   };
-  const cql = new ContextQL(store);
-  return cql.execute(params);
+  let updatedLockfile = updateLockfileEntry(lockfile, packageName, entry);
+  writeLockfile2(lockfilePath, updatedLockfile);
+  const result = {
+    installed: true,
+    name: packageName,
+    version: resolvedVersion
+  };
+  if (previousVersion && previousVersion !== resolvedVersion) {
+    result.upgraded = true;
+    result.previousVersion = previousVersion;
+  }
+  const deps = skillYaml.depends_on ?? [];
+  for (const dep of deps) {
+    logger.info(`Installing dependency: ${dep} (required by ${shortName})`);
+    await runInstall(dep, {
+      _dependencyOf: packageName,
+      ...options.registry !== void 0 ? { registry: options.registry } : {}
+    });
+  }
+  return result;
 }
-function createQueryCommand() {
-  return new Command38("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path25.resolve(globalOpts.config ? path25.dirname(globalOpts.config) : ".");
+function createInstallCommand() {
+  const cmd = new Command48("install");
+  cmd.description("Install a community skill from the @harness-skills registry").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--version <range>", "Semver range or exact version to install").option("--force", "Force reinstall even if same version is already installed").option("--from <path>", "Install from a local directory or .tgz file").option("--registry <url>", "Use a custom npm registry URL").action(async (skill, opts) => {
     try {
-      const result = await runQuery(projectPath, rootNodeId, {
-        depth: parseInt(opts.depth),
-        types: opts.types,
-        edges: opts.edges,
-        bidirectional: opts.bidirectional
-      });
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result, null, 2));
-      } else {
-        console.log(
-          `Found ${result.nodes.length} nodes, ${result.edges.length} edges (depth ${result.stats.depthReached}, pruned ${result.stats.pruned})`
+      const result = await runInstall(skill, opts);
+      if (result.skipped) {
+        logger.info(
+          `${result.name}@${result.version} is already installed. Use --force to reinstall.`
         );
-        for (const node of result.nodes) {
-          console.log(`  ${node.type.padEnd(12)} ${node.id}`);
-        }
+      } else if (result.upgraded) {
+        logger.success(
+          `Upgraded ${result.name} from ${result.previousVersion} to ${result.version}`
+        );
+      } else {
+        logger.success(`Installed ${result.name}@${result.version}`);
       }
     } catch (err) {
-      console.error("Query failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
     }
   });
+  return cmd;
 }
 
-// src/commands/graph/index.ts
-import { Command as Command39 } from "commander";
-
-// src/commands/graph/status.ts
-import * as path26 from "path";
-async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path26.join(projectPath, ".harness", "graph");
-  const store = new GraphStore();
-  const loaded = await store.load(graphDir);
-  if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
-  const fs11 = await import("fs/promises");
-  const metaPath = path26.join(graphDir, "metadata.json");
-  let lastScan = "unknown";
+// src/commands/install-constraints.ts
+import * as fs21 from "fs/promises";
+import * as path40 from "path";
+import { Command as Command49 } from "commander";
+import semver3 from "semver";
+async function runInstallConstraints(options) {
+  const { source, configPath, lockfilePath } = options;
+  let rawBundle;
   try {
-    const meta = JSON.parse(await fs11.readFile(metaPath, "utf-8"));
-    lastScan = meta.lastScanTimestamp;
+    rawBundle = await fs21.readFile(source, "utf-8");
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return { ok: false, error: `Bundle file not found: ${source}` };
+    }
+    return {
+      ok: false,
+      error: `Failed to read bundle: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(rawBundle);
   } catch {
+    return { ok: false, error: `Bundle file contains invalid JSON: ${source}` };
   }
-  const allNodes = store.findNodes({});
-  const nodesByType = {};
-  for (const node of allNodes) {
-    nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+  const bundleResult = BundleSchema.safeParse(parsedJson);
+  if (!bundleResult.success) {
+    const issues = bundleResult.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    return { ok: false, error: `Bundle schema validation failed: ${issues}` };
   }
-  let connectorSyncStatus = {};
+  const bundle = bundleResult.data;
+  if (bundle.minHarnessVersion) {
+    const installed = semver3.valid(semver3.coerce(CLI_VERSION));
+    const required = semver3.valid(semver3.coerce(bundle.minHarnessVersion));
+    if (installed && required && semver3.lt(installed, required)) {
+      return {
+        ok: false,
+        error: `Bundle requires harness version >= ${bundle.minHarnessVersion}, but installed version is ${CLI_VERSION}. Please upgrade.`
+      };
+    }
+  }
+  const constraintKeys = Object.keys(bundle.constraints).filter(
+    (k) => bundle.constraints[k] !== void 0
+  );
+  if (constraintKeys.length === 0) {
+    return {
+      ok: false,
+      error: "Bundle contains no constraints. Nothing to install."
+    };
+  }
+  let localConfig;
   try {
-    const syncMetaPath = path26.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs11.readFile(syncMetaPath, "utf-8"));
-    for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
-      connectorSyncStatus[name] = data.lastSyncTimestamp;
+    const raw = await fs21.readFile(configPath, "utf-8");
+    localConfig = JSON.parse(raw);
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Failed to read local config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const lockfileResult = await readLockfile(lockfilePath);
+  if (!lockfileResult.ok) {
+    return { ok: false, error: lockfileResult.error };
+  }
+  const existingLockfile = lockfileResult.value ?? {
+    version: 1,
+    packages: {}
+  };
+  const existingEntry = existingLockfile.packages[bundle.name];
+  if (existingEntry && existingEntry.version === bundle.version) {
+    return {
+      ok: true,
+      value: {
+        installed: false,
+        packageName: bundle.name,
+        version: bundle.version,
+        contributionsCount: 0,
+        conflicts: [],
+        alreadyInstalled: true
+      }
+    };
+  }
+  if (existingEntry) {
+    const oldContributions = existingEntry.contributions ?? {};
+    localConfig = removeContributions(localConfig, oldContributions);
+  }
+  const mergeResult = deepMergeConstraints(localConfig, bundle.constraints);
+  if (mergeResult.conflicts.length > 0) {
+    if (options.forceLocal) {
+    } else if (options.forcePackage) {
+      for (const conflict of mergeResult.conflicts) {
+        applyPackageValue(mergeResult.config, conflict);
+        addConflictContribution(mergeResult.contributions, conflict);
+      }
+    } else if (!options.dryRun) {
+      return {
+        ok: false,
+        error: formatConflictsError(mergeResult.conflicts)
+      };
     }
-  } catch {
+  }
+  if (options.dryRun) {
+    return {
+      ok: true,
+      value: {
+        installed: false,
+        packageName: bundle.name,
+        version: bundle.version,
+        contributionsCount: Object.keys(mergeResult.contributions).length,
+        conflicts: mergeResult.conflicts,
+        dryRun: true
+      }
+    };
+  }
+  const writeResult = await writeConfig(configPath, mergeResult.config);
+  if (!writeResult.ok) {
+    return {
+      ok: false,
+      error: `Failed to write config: ${writeResult.error instanceof Error ? writeResult.error.message : String(writeResult.error)}`
+    };
+  }
+  const lockfileEntry = {
+    version: bundle.version,
+    source,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contributions: mergeResult.contributions
+  };
+  const updatedLockfile = addProvenance(existingLockfile, bundle.name, lockfileEntry);
+  const lockfileWriteResult = await writeLockfile(lockfilePath, updatedLockfile);
+  if (!lockfileWriteResult.ok) {
+    return {
+      ok: false,
+      error: `Config was written but lockfile write failed: ${lockfileWriteResult.error.message}. Lockfile may be out of sync.`
+    };
   }
   return {
-    status: "ok",
-    nodeCount: store.nodeCount,
-    edgeCount: store.edgeCount,
-    nodesByType,
-    lastScanTimestamp: lastScan,
-    ...Object.keys(connectorSyncStatus).length > 0 ? { connectorSyncStatus } : {}
+    ok: true,
+    value: {
+      installed: true,
+      packageName: bundle.name,
+      version: bundle.version,
+      contributionsCount: Object.keys(mergeResult.contributions).length,
+      conflicts: mergeResult.conflicts
+    }
   };
 }
-
-// src/commands/graph/export.ts
-import * as path27 from "path";
-async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path27.join(projectPath, ".harness", "graph");
-  const store = new GraphStore();
-  const loaded = await store.load(graphDir);
-  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
-  if (format === "json") {
-    const nodes = store.findNodes({});
-    const edges = store.getEdges({});
-    return JSON.stringify({ nodes, edges }, null, 2);
-  }
-  if (format === "mermaid") {
-    const nodes = store.findNodes({});
-    const edges = store.getEdges({});
-    const lines = ["graph TD"];
-    for (const node of nodes.slice(0, 200)) {
-      const safeId = node.id.replace(/[^a-zA-Z0-9]/g, "_");
-      const safeName = node.name.replace(/"/g, "#quot;");
-      lines.push(`  ${safeId}["${safeName}"]`);
+var sectionAppliers = {
+  layers(config, key, value) {
+    const layers = config.layers;
+    const idx = layers.findIndex((l) => l.name === key);
+    if (idx >= 0) layers[idx] = value;
+  },
+  forbiddenImports(config, key, value) {
+    const rules = config.forbiddenImports;
+    const idx = rules.findIndex((r) => r.from === key);
+    if (idx >= 0) rules[idx] = value;
+  },
+  "architecture.thresholds"(config, key, value) {
+    const arch = config.architecture;
+    if (arch?.thresholds) arch.thresholds[key] = value;
+  },
+  "architecture.modules"(config, key, value) {
+    const arch = config.architecture;
+    const [modulePath, category] = key.split(":");
+    if (arch?.modules && modulePath && category && arch.modules[modulePath]) {
+      arch.modules[modulePath][category] = value;
     }
-    for (const edge of edges.slice(0, 500)) {
-      const safeFrom = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
-      const safeTo = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
-      lines.push(`  ${safeFrom} -->|${edge.type}| ${safeTo}`);
+  },
+  "security.rules"(config, key, value) {
+    const security = config.security;
+    if (security?.rules) security.rules[key] = value;
+  }
+};
+function applyPackageValue(config, conflict) {
+  const applier = sectionAppliers[conflict.section];
+  if (applier) applier(config, conflict.key, conflict.packageValue);
+}
+function addConflictContribution(contributions, conflict) {
+  const section = conflict.section;
+  const existing = contributions[section] ?? [];
+  existing.push(conflict.key);
+  contributions[section] = existing;
+}
+function formatConflictsError(conflicts) {
+  const lines = [
+    `${conflicts.length} conflict(s) detected. Resolve with --force-local or --force-package:`,
+    ""
+  ];
+  for (const c of conflicts) {
+    lines.push(`  [${c.section}] ${c.key}: ${c.description}`);
+    lines.push(`    Local:   ${JSON.stringify(c.localValue)}`);
+    lines.push(`    Package: ${JSON.stringify(c.packageValue)}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function resolveConfigPath(opts) {
+  if (opts.config) return path40.resolve(opts.config);
+  const found = findConfigFile();
+  if (!found.ok) {
+    logger.error(found.error.message);
+    process.exit(1);
+  }
+  return found.value;
+}
+function logInstallResult(val, opts) {
+  if (val.dryRun) {
+    logger.info(`[dry-run] Would install ${val.packageName}@${val.version}`);
+    logger.info(`[dry-run] ${val.contributionsCount} section(s) would be added`);
+    if (val.conflicts.length > 0) {
+      logger.warn(`[dry-run] ${val.conflicts.length} conflict(s) detected`);
+      for (const c of val.conflicts) {
+        logger.warn(`  [${c.section}] ${c.key}: ${c.description}`);
+      }
     }
-    return lines.join("\n");
+    return;
   }
-  throw new Error(`Unknown format: ${format}. Available: json, mermaid`);
+  if (val.alreadyInstalled) {
+    logger.info(`${val.packageName}@${val.version} is already installed. No changes made.`);
+    return;
+  }
+  logger.success(
+    `Installed ${val.packageName}@${val.version} (${val.contributionsCount} section(s) merged)`
+  );
+  if (val.conflicts.length > 0) {
+    logger.warn(
+      `${val.conflicts.length} conflict(s) resolved with ${opts.forceLocal ? "--force-local" : "--force-package"}`
+    );
+  }
+}
+async function handleInstallConstraints(source, opts) {
+  const configPath = resolveConfigPath(opts);
+  const projectRoot = path40.dirname(configPath);
+  const lockfilePath = path40.join(projectRoot, ".harness", "constraints.lock.json");
+  const resolvedSource = path40.resolve(source);
+  if (opts.forceLocal && opts.forcePackage) {
+    logger.error("Cannot use both --force-local and --force-package.");
+    process.exit(1);
+  }
+  const result = await runInstallConstraints({
+    source: resolvedSource,
+    configPath,
+    lockfilePath,
+    ...opts.forceLocal && { forceLocal: true },
+    ...opts.forcePackage && { forcePackage: true },
+    ...opts.dryRun && { dryRun: true }
+  });
+  if (!result.ok) {
+    logger.error(result.error);
+    process.exit(1);
+  }
+  logInstallResult(result.value, opts);
+}
+function createInstallConstraintsCommand() {
+  const cmd = new Command49("install-constraints");
+  cmd.description("Install a constraints bundle into the local harness config").argument("<source>", "Path to a .harness-constraints.json bundle file").option("--force-local", "Resolve all conflicts by keeping local values").option("--force-package", "Resolve all conflicts by using package values").option("--dry-run", "Show what would change without writing files").option("-c, --config <path>", "Path to harness.config.json").action(handleInstallConstraints);
+  return cmd;
 }
 
-// src/commands/graph/index.ts
-import * as path28 from "path";
-function createGraphCommand() {
-  const graph = new Command39("graph").description("Knowledge graph management");
-  graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
-    try {
-      const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
-      const result = await runGraphStatus(projectPath);
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result, null, 2));
-      } else if (result.status === "no_graph") {
-        console.log(result.message);
-      } else {
-        console.log(`Graph: ${result.nodeCount} nodes, ${result.edgeCount} edges`);
-        console.log(`Last scan: ${result.lastScanTimestamp}`);
-        console.log("Nodes by type:");
-        for (const [type, count] of Object.entries(result.nodesByType)) {
-          console.log(`  ${type}: ${count}`);
-        }
-        if (result.connectorSyncStatus) {
-          console.log("Connector sync status:");
-          for (const [name, timestamp] of Object.entries(result.connectorSyncStatus)) {
-            console.log(`  ${name}: last synced ${timestamp}`);
-          }
-        }
+// src/commands/uninstall-constraints.ts
+import * as fs22 from "fs/promises";
+import * as path41 from "path";
+import { Command as Command50 } from "commander";
+async function runUninstallConstraints(options) {
+  const { packageName, configPath, lockfilePath } = options;
+  const lockfileResult = await readLockfile(lockfilePath);
+  if (!lockfileResult.ok) {
+    return { ok: false, error: lockfileResult.error };
+  }
+  if (lockfileResult.value === null) {
+    return { ok: false, error: "No lockfile found. No constraint packages are installed." };
+  }
+  const lockfile = lockfileResult.value;
+  const entry = lockfile.packages[packageName];
+  if (!entry) {
+    return {
+      ok: false,
+      error: `Package '${packageName}' is not installed.`
+    };
+  }
+  let localConfig;
+  try {
+    const raw = await fs22.readFile(configPath, "utf-8");
+    localConfig = JSON.parse(raw);
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Failed to read local config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const contributions = entry.contributions ?? {};
+  const sectionsRemoved = Object.keys(contributions);
+  const updatedConfig = removeContributions(localConfig, contributions);
+  const { lockfile: updatedLockfile } = removeProvenance(lockfile, packageName);
+  const writeResult = await writeConfig(configPath, updatedConfig);
+  if (!writeResult.ok) {
+    return {
+      ok: false,
+      error: `Failed to write config: ${writeResult.error instanceof Error ? writeResult.error.message : String(writeResult.error)}`
+    };
+  }
+  const lockfileWriteResult = await writeLockfile(lockfilePath, updatedLockfile);
+  if (!lockfileWriteResult.ok) {
+    return {
+      ok: false,
+      error: `Config was written but lockfile write failed: ${lockfileWriteResult.error.message}. Lockfile may be out of sync.`
+    };
+  }
+  return {
+    ok: true,
+    value: {
+      removed: true,
+      packageName,
+      version: entry.version,
+      sectionsRemoved
+    }
+  };
+}
+function createUninstallConstraintsCommand() {
+  const cmd = new Command50("uninstall-constraints");
+  cmd.description("Remove a previously installed constraints package").argument("<name>", "Name of the constraint package to uninstall").option("-c, --config <path>", "Path to harness.config.json").action(async (name, opts) => {
+    let configPath;
+    if (opts.config) {
+      configPath = path41.resolve(opts.config);
+    } else {
+      const found = findConfigFile();
+      if (!found.ok) {
+        logger.error(found.error.message);
+        process.exit(1);
       }
-    } catch (err) {
-      console.error("Status failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
+      configPath = found.value;
+    }
+    const projectRoot = path41.dirname(configPath);
+    const lockfilePath = path41.join(projectRoot, ".harness", "constraints.lock.json");
+    const result = await runUninstallConstraints({
+      packageName: name,
+      configPath,
+      lockfilePath
+    });
+    if (!result.ok) {
+      logger.error(result.error);
+      process.exit(1);
+    }
+    const val = result.value;
+    if (val.sectionsRemoved.length === 0) {
+      logger.success(
+        `Removed ${val.packageName}@${val.version} (no contributed rules to remove)`
+      );
+    } else {
+      logger.success(
+        `Removed ${val.packageName}@${val.version} (${val.sectionsRemoved.length} section(s): ${val.sectionsRemoved.join(", ")})`
+      );
     }
   });
-  graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
+  return cmd;
+}
+
+// src/commands/uninstall.ts
+import * as path42 from "path";
+import { Command as Command51 } from "commander";
+async function runUninstall(skillName, options) {
+  const packageName = resolvePackageName(skillName);
+  const shortName = extractSkillName(packageName);
+  const globalDir = resolveGlobalSkillsDir();
+  const skillsDir = path42.dirname(globalDir);
+  const communityBase = path42.join(skillsDir, "community");
+  const lockfilePath = path42.join(communityBase, "skills-lock.json");
+  const lockfile = readLockfile2(lockfilePath);
+  const entry = lockfile.skills[packageName];
+  if (!entry) {
+    throw new Error(`Skill '${shortName}' is not installed.`);
+  }
+  const dependents = findDependentsOf(lockfile, packageName);
+  const warnings = [];
+  if (dependents.length > 0) {
+    if (!options.force) {
+      throw new Error(
+        `Cannot uninstall '${shortName}' because it is required by: ${dependents.join(", ")}. Use --force to remove anyway.`
+      );
+    }
+    warnings.push(`Forced removal despite dependents: ${dependents.join(", ")}`);
+  }
+  removeSkillContent(communityBase, shortName, entry.platforms);
+  const updatedLockfile = removeLockfileEntry(lockfile, packageName);
+  writeLockfile2(lockfilePath, updatedLockfile);
+  const result = {
+    removed: true,
+    name: packageName,
+    version: entry.version
+  };
+  if (warnings.length > 0) {
+    result.warnings = warnings;
+  }
+  return result;
+}
+function createUninstallCommand() {
+  const cmd = new Command51("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 output = await runGraphExport(projectPath, opts.format);
-      console.log(output);
+      const result = await runUninstall(skill, opts);
+      if (result.warnings) {
+        for (const warning of result.warnings) {
+          logger.warn(warning);
+        }
+      }
+      logger.success(`Uninstalled ${result.name}@${result.version}`);
     } catch (err) {
-      console.error("Export failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
     }
   });
-  return graph;
+  return cmd;
 }
 
-// src/commands/mcp.ts
-import { Command as Command40 } from "commander";
-function createMcpCommand() {
-  return new Command40("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
-    const { startServer: startServer2 } = await import("./mcp-BNLBTCXZ.js");
-    await startServer2();
+// src/commands/orchestrator.ts
+import { Command as Command52 } from "commander";
+import * as path43 from "path";
+import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
+function createOrchestratorCommand() {
+  const orchestrator = new Command52("orchestrator");
+  orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to WORKFLOW.md", "WORKFLOW.md").action(async (opts) => {
+    const workflowPath = path43.resolve(process.cwd(), opts.workflow);
+    const loader = new WorkflowLoader();
+    const result = await loader.loadWorkflow(workflowPath);
+    if (!result.ok) {
+      logger.error(`Failed to load workflow: ${result.error.message}`);
+      process.exit(ExitCode.ERROR);
+    }
+    const { config, promptTemplate } = result.value;
+    const daemon = new Orchestrator(config, promptTemplate);
+    const shutdown = () => {
+      daemon.stop();
+      process.exit(ExitCode.SUCCESS);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    daemon.start();
+    const { waitUntilExit } = launchTUI(daemon);
+    await waitUntilExit();
+    process.exit(ExitCode.SUCCESS);
   });
+  return orchestrator;
 }
 
 // src/index.ts
 function createProgram() {
-  const program = new Command41();
+  const program = new Command53();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
@@ -3240,6 +5140,15 @@ function createProgram() {
   program.addCommand(createQueryCommand());
   program.addCommand(createGraphCommand());
   program.addCommand(createMcpCommand());
+  program.addCommand(createImpactPreviewCommand());
+  program.addCommand(createCheckArchCommand());
+  program.addCommand(createBlueprintCommand());
+  program.addCommand(createShareCommand());
+  program.addCommand(createInstallCommand());
+  program.addCommand(createInstallConstraintsCommand());
+  program.addCommand(createUninstallConstraintsCommand());
+  program.addCommand(createUninstallCommand());
+  program.addCommand(createOrchestratorCommand());
   return program;
 }
 
@@ -3250,5 +5159,11 @@ export {
   runQuery,
   runGraphStatus,
   runGraphExport,
+  runImpactPreview,
+  runCheckArch,
+  runInstall,
+  runInstallConstraints,
+  runUninstallConstraints,
+  runUninstall,
   createProgram
 };