@harness-engineering/cli 1.10.0 → 1.11.0

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

@@ -7,11 +7,11 @@ import {
   createCheckPhaseGateCommand,
   findFiles,
   resolveConfig
-} from "./chunk-7X7ZAYMY.js";
+} from "./chunk-2NCIKJES.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-46YA6FI3.js";
+} from "./chunk-GNGELAXY.js";
 import {
   listPersonas,
   loadPersona
@@ -21,16 +21,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 +47,27 @@ import {
 import {
   createGenerateSlashCommandsCommand,
   generateSlashCommands,
+  handleGetImpact,
   handleOrphanDeletion
-} from "./chunk-LXU5M77O.js";
+} from "./chunk-I6JZYEGT.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,9 +75,13 @@ import {
   TemplateEngine
 } from "./chunk-C2ERUR3L.js";
 import {
+  ArchBaselineManager,
+  ArchConfigSchema,
   BaselineManager,
+  BlueprintGenerator,
   CriticalPathResolver,
   EntropyAnalyzer,
+  ProjectScanner,
   SecurityScanner,
   TypeScriptParser,
   appendLearning,
@@ -88,28 +95,33 @@ import {
   detectCircularDepsInFiles,
   detectDeadCode,
   detectDocDrift,
+  diff,
+  extractBundle,
   generateSuggestions,
   listStreams,
   loadState,
   loadStreamIndex,
   parseDiff,
+  parseManifest,
   parseSecurityConfig,
   requestPeerReview,
   resolveStreamPath,
+  runAll,
   runCIChecks,
   runReviewPipeline,
   setActiveStream,
   validateAgentsMap,
   validateDependencies,
-  validateKnowledgeMap
-} from "./chunk-NX6DSZSM.js";
+  validateKnowledgeMap,
+  writeConfig
+} from "./chunk-2YSQOUHO.js";
 import {
   Err,
   Ok
 } from "./chunk-MHBMTPW7.js";
 
 // src/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/commands/validate.ts
 import { Command } from "commander";
@@ -188,7 +200,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-DB7RIFFF.js");
       const cwd = process.cwd();
       const specsDir = path.join(cwd, "docs", "specs");
       const plansDir = path.join(cwd, "docs", "plans");
@@ -314,13 +326,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 +468,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path4.resolve(cwd);
   let configData = {};
   try {
-    const fs11 = await import("fs");
+    const fs20 = await import("fs");
     const configPath = path4.join(projectRoot, "harness.config.json");
-    if (fs11.existsSync(configPath)) {
-      const raw = fs11.readFileSync(configPath, "utf-8");
+    if (fs20.existsSync(configPath)) {
+      const raw = fs20.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -546,7 +558,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-JVZ2MKBC.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
@@ -615,7 +627,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-JVZ2MKBC.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -628,8 +640,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 +655,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-JVZ2MKBC.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -717,7 +729,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 +1415,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 +1444,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 +1611,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 +1876,161 @@ 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 readLockfile(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 writeLockfile(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 lockfilePath = path15.join(communityBase, "skills-lock.json");
+    const lockfile = readLockfile(lockfilePath);
+    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 +2041,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 +2056,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 +2147,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 +2168,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 +2193,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 +2221,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 +2249,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 +2263,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 +2330,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,138 +2389,623 @@ 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;
+// src/registry/npm-client.ts
+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;
+}
+async function fetchPackageMetadata(packageName) {
+  const encodedName = encodeURIComponent(packageName);
+  const url = `${NPM_REGISTRY}/${encodedName}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      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.`);
     }
-    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`);
+    throw new Error(
+      `npm registry returned ${response.status} ${response.statusText} for ${packageName}.`
+    );
+  }
+  return await response.json();
+}
+async function downloadTarball(tarballUrl) {
+  let lastError;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const response = await fetch(tarballUrl, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      });
+      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));
     }
-    process.exit(ExitCode.SUCCESS);
-  });
+  }
+  throw new Error(`Download failed for ${tarballUrl}. Try again. (${lastError?.message})`);
+}
+async function searchNpmRegistry(query) {
+  const searchText = encodeURIComponent(`scope:harness-skills ${query}`);
+  const url = `${NPM_REGISTRY}/-/v1/search?text=${searchText}&size=20`;
+  let response;
+  try {
+    response = await fetch(url, {
+      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/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");
+// src/commands/skill/search.ts
+async function runSearch(query, opts) {
+  const results = await searchNpmRegistry(query);
+  return results.filter((r) => {
+    if (opts.platform && !r.keywords.includes(opts.platform)) {
+      return false;
     }
-    if (!fs9.existsSync(statePath)) {
-      logger.info("No state file found. Nothing to reset.");
-      process.exit(ExitCode.SUCCESS);
-      return;
+    if (opts.trigger && !r.keywords.includes(opts.trigger)) {
+      return false;
     }
-    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);
-      });
-      rl.close();
-      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
-        logger.info("Reset cancelled.");
+    return true;
+  });
+}
+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)").action(async (query, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    try {
+      const results = await runSearch(query, opts);
+      if (globalOpts.json) {
+        logger.raw(results);
         process.exit(ExitCode.SUCCESS);
         return;
       }
+      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);
     }
-    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);
   });
 }
 
-// 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;
-    }
-    logger.success(`Learning recorded.`);
-    process.exit(ExitCode.SUCCESS);
-  });
+// src/commands/skill/create.ts
+import { Command as Command26 } from "commander";
+import * as path19 from "path";
+import * as fs10 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}
+
+${description}
+
+## 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: []
+  };
 }
+function buildSkillMd(name, description) {
+  return `# ${name}
 
-// 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) => {
+${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 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 ?? path19.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path19.join(baseDir, name);
+  if (fs10.existsSync(skillDir)) {
+    throw new Error(`Skill directory already exists: ${skillDir}`);
+  }
+  fs10.mkdirSync(skillDir, { recursive: true });
+  const description = opts.description || `A community skill: ${name}`;
+  const skillYaml = buildSkillYaml(name, opts);
+  const skillYamlPath = path19.join(skillDir, "skill.yaml");
+  fs10.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillMd = buildSkillMd(name, description);
+  const skillMdPath = path19.join(skillDir, "SKILL.md");
+  fs10.writeFileSync(skillMdPath, skillMd);
+  const readme = buildReadme(name, description);
+  const readmePath = path19.join(skillDir, "README.md");
+  fs10.writeFileSync(readmePath, readme);
+  return {
+    name,
+    directory: skillDir,
+    files: [skillYamlPath, skillMdPath, readmePath]
+  };
+}
+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 projectPath = path21.resolve(opts.path);
+    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.success(`Created skill "${name}"`);
+        for (const f of result.files) {
+          logger.info(`  ${f}`);
+        }
+        logger.info(`
+Next steps:`);
+        logger.info(
+          `  1. Edit ${path19.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);
+    }
+  });
+}
+
+// src/commands/skill/publish.ts
+import { Command as Command27 } from "commander";
+import * as fs13 from "fs";
+import * as path21 from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+
+// src/registry/validator.ts
+import * as fs12 from "fs";
+import * as path20 from "path";
+import { parse as parse5 } from "yaml";
+import semver from "semver";
+
+// src/registry/bundled-skills.ts
+import * as fs11 from "fs";
+function getBundledSkillNames(bundledSkillsDir) {
+  if (!fs11.existsSync(bundledSkillsDir)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const entries = fs11.readdirSync(bundledSkillsDir);
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    try {
+      const stat = fs11.statSync(`${bundledSkillsDir}/${entry}`);
+      if (stat.isDirectory()) {
+        names.add(String(entry));
+      }
+    } catch {
+    }
+  }
+  return names;
+}
+
+// src/registry/validator.ts
+async function validateForPublish(skillDir) {
+  const errors = [];
+  const skillYamlPath = path20.join(skillDir, "skill.yaml");
+  if (!fs12.existsSync(skillYamlPath)) {
+    errors.push("skill.yaml not found. Create one with: harness skill create <name>");
+    return { valid: false, errors };
+  }
+  let skillMeta;
+  try {
+    const raw = fs12.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 = path20.join(skillDir, "SKILL.md");
+  if (!fs12.existsSync(skillMdPath)) {
+    errors.push("SKILL.md not found. Create it with content describing your skill.");
+  } else {
+    const content = fs12.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);
+    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 {
+  }
+  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);
+      } 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 } : {}
+  };
+}
+
+// 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;
+}
+
+// src/commands/skill/publish.ts
+async function runPublish(skillDir, opts) {
+  const validation = await validateForPublish(skillDir);
+  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 = path21.join(skillDir, "package.json");
+  fs13.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path21.join(skillDir, "README.md");
+  if (!fs13.existsSync(readmePath)) {
+    const skillMdContent = fs13.readFileSync(path21.join(skillDir, "SKILL.md"), "utf-8");
+    const readme = `# ${pkg.name}
+
+${meta.description}
+
+## Installation
+
+\`\`\`bash
+harness install ${meta.name}
+\`\`\`
+
+---
+
+${skillMdContent}`;
+    fs13.writeFileSync(readmePath, readme);
+  }
+  if (opts.dryRun) {
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      published: false,
+      dryRun: true
+    };
+  }
+  execFileSync3("npm", ["publish", "--access", "public"], {
+    cwd: skillDir,
+    stdio: "pipe",
+    timeout: 6e4
+  });
+  return {
+    name: pkg.name,
+    version: pkg.version,
+    published: true
+  };
+}
+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)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const skillDir = opts.dir || process.cwd();
+    try {
+      const result = await runPublish(skillDir, {
+        dryRun: opts.dryRun
+      });
+      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);
+    }
+  });
+}
+
+// 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 path22 from "path";
+function createShowCommand() {
+  return new Command29("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path22.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}`);
+        }
+      }
+      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 fs14 from "fs";
+import * as path23 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 = path23.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 = path23.join(streamResult.value, "state.json");
+    } else {
+      statePath = path23.join(projectPath, ".harness", "state.json");
+    }
+    if (!fs14.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((resolve24) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve24);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        logger.info("Reset cancelled.");
+        process.exit(ExitCode.SUCCESS);
+        return;
+      }
+    }
+    try {
+      fs14.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 path24 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 = path24.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 path25 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 = path25.resolve(opts.path);
     const indexResult = await loadStreamIndex(projectPath);
     const result = await listStreams(projectPath);
     if (!result.ok) {
@@ -2398,7 +3029,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
+    const projectPath = path25.resolve(opts.path);
     const result = await createStream(projectPath, name, opts.branch);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -2409,7 +3040,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
+    const projectPath = path25.resolve(opts.path);
     const result = await archiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -2420,7 +3051,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path21.resolve(opts.path);
+    const projectPath = path25.resolve(opts.path);
     const result = await setActiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -2435,7 +3066,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command30("state").description("Project state management commands");
+  const command = new Command33("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -2444,11 +3075,20 @@ function createStateCommand() {
 }
 
 // src/commands/ci/index.ts
-import { Command as Command33 } from "commander";
+import { Command as Command36 } from "commander";
 
 // src/commands/ci/check.ts
-import { Command as Command31 } from "commander";
-var VALID_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
+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) {
@@ -2478,7 +3118,7 @@ function parseFailOn(failOn) {
   return "error";
 }
 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) => {
+  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);
@@ -2522,10 +3162,19 @@ function createCheckCommand() {
 }
 
 // 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"];
+import { Command as Command35 } from "commander";
+import * as fs15 from "fs";
+import * as path26 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));
@@ -2616,12 +3265,12 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs10.existsSync(".github")) return "github";
-  if (fs10.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs15.existsSync(".github")) return "github";
+  if (fs15.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 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) => {
+  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;
@@ -2633,12 +3282,12 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path22.resolve(filename);
-    const dir = path22.dirname(targetPath);
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(targetPath, content);
+    const targetPath = path26.resolve(filename);
+    const dir = path26.dirname(targetPath);
+    fs15.mkdirSync(dir, { recursive: true });
+    fs15.writeFileSync(targetPath, content);
     if (platform === "generic" && process.platform !== "win32") {
-      fs10.chmodSync(targetPath, "755");
+      fs15.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -2651,15 +3300,15 @@ function createInitCommand2() {
 
 // src/commands/ci/index.ts
 function createCICommand() {
-  const command = new Command33("ci").description("CI/CD integration commands");
+  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 Command34 } from "commander";
-import { execFileSync as execFileSync3 } from "child_process";
+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";
@@ -2681,7 +3330,7 @@ function detectPackageManager() {
   return "npm";
 }
 function getLatestVersion(pkg = "@harness-engineering/cli") {
-  const output = execFileSync3("npm", ["view", pkg, "dist-tags.latest"], {
+  const output = execFileSync4("npm", ["view", pkg, "dist-tags.latest"], {
     encoding: "utf-8",
     timeout: 15e3
   });
@@ -2689,7 +3338,7 @@ function getLatestVersion(pkg = "@harness-engineering/cli") {
 }
 function getInstalledVersion(pm) {
   try {
-    const output = execFileSync3(pm, ["list", "-g", "@harness-engineering/cli", "--json"], {
+    const output = execFileSync4(pm, ["list", "-g", "@harness-engineering/cli", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -2702,7 +3351,7 @@ function getInstalledVersion(pm) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execFileSync3(pm, ["list", "-g", "--json"], {
+    const output = execFileSync4(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -2718,15 +3367,15 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve20) => {
+  return new Promise((resolve24) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve20(answer.trim().toLowerCase());
+      resolve24(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) => {
+  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) {
@@ -2769,7 +3418,7 @@ function createUpdateCommand() {
     }
     try {
       logger.info("Updating packages...");
-      execFileSync3(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
+      execFileSync4(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
       console.log("");
       logger.success("Update complete");
     } catch {
@@ -2779,12 +3428,12 @@ function createUpdateCommand() {
       process.exit(ExitCode.ERROR);
     }
     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";
+    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 {
-        execFileSync3("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+        execFileSync4("harness", ["generate", ...isGlobal ? ["--global"] : []], {
           stdio: "inherit"
         });
       } catch {
@@ -2797,9 +3446,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/generate.ts
-import { Command as Command35 } from "commander";
+import { Command as Command38 } 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) => {
+  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) {
@@ -2858,10 +3507,10 @@ function createGenerateCommand3() {
 }
 
 // src/commands/graph/scan.ts
-import { Command as Command36 } from "commander";
-import * as path23 from "path";
+import { Command as Command39 } from "commander";
+import * as path27 from "path";
 async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-I7DB5VKB.js");
+  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);
@@ -2872,13 +3521,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path23.join(projectPath, ".harness", "graph");
+  const graphDir = path27.join(projectPath, ".harness", "graph");
   await store.save(graphDir);
   return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
 }
 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);
+  return new Command39("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path27.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -2897,13 +3546,13 @@ function createScanCommand() {
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command37 } from "commander";
-import * as path24 from "path";
+import { Command as Command40 } from "commander";
+import * as path28 from "path";
 async function loadConnectorConfig(projectPath, source) {
   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 fs20 = await import("fs/promises");
+    const configPath = path28.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs20.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
     );
@@ -2942,8 +3591,8 @@ async function runIngest(projectPath, source, opts) {
     SyncManager,
     JiraConnector,
     SlackConnector
-  } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path24.join(projectPath, ".harness", "graph");
+  } = await import("./dist-M6BQODWC.js");
+  const graphDir = path28.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -3004,13 +3653,13 @@ async function runIngest(projectPath, source, opts) {
   return result;
 }
 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) => {
+  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 = path24.resolve(globalOpts.config ? path24.dirname(globalOpts.config) : ".");
+    const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -3032,12 +3681,12 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/query.ts
-import { Command as Command38 } from "commander";
-import * as path25 from "path";
+import { Command as Command41 } from "commander";
+import * as path29 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-I7DB5VKB.js");
+  const { GraphStore, ContextQL } = await import("./dist-M6BQODWC.js");
   const store = new GraphStore();
-  const graphDir = path25.join(projectPath, ".harness", "graph");
+  const graphDir = path29.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -3051,9 +3700,9 @@ async function runQuery(projectPath, rootNodeId, opts) {
   return cql.execute(params);
 }
 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) => {
+  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 = path25.resolve(globalOpts.config ? path25.dirname(globalOpts.config) : ".");
+    const projectPath = path29.resolve(globalOpts.config ? path29.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -3079,21 +3728,21 @@ function createQueryCommand() {
 }
 
 // src/commands/graph/index.ts
-import { Command as Command39 } from "commander";
+import { Command as Command42 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path26 from "path";
+import * as path30 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path26.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-M6BQODWC.js");
+  const graphDir = path30.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");
+  const fs20 = await import("fs/promises");
+  const metaPath = path30.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs11.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs20.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -3104,8 +3753,8 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path26.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs11.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path30.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs20.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -3122,10 +3771,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path27 from "path";
+import * as path31 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-I7DB5VKB.js");
-  const graphDir = path27.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-M6BQODWC.js");
+  const graphDir = path31.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.");
@@ -3154,13 +3803,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path28 from "path";
+import * as path32 from "path";
 function createGraphCommand() {
-  const graph = new Command39("graph").description("Knowledge graph management");
+  const graph = new Command42("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
     try {
       const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
+      const projectPath = path32.resolve(globalOpts.config ? path32.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -3187,7 +3836,7 @@ function createGraphCommand() {
   });
   graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
+    const projectPath = path32.resolve(globalOpts.config ? path32.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);
@@ -3200,17 +3849,770 @@ function createGraphCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command40 } from "commander";
+import { Command as Command43 } 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");
+  return new Command43("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
+    const { startServer: startServer2 } = await import("./mcp-MOKLYNZL.js");
     await startServer2();
   });
 }
 
+// src/commands/impact-preview.ts
+import { Command as Command44 } from "commander";
+import { execSync as execSync3 } from "child_process";
+import * as path33 from "path";
+import * as fs16 from "fs";
+function getStagedFiles(cwd) {
+  try {
+    const output = execSync3("git diff --cached --name-only", {
+      cwd,
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter((f) => f.length > 0);
+  } catch {
+    return [];
+  }
+}
+function graphExists(projectPath) {
+  try {
+    return fs16.existsSync(path33.join(projectPath, ".harness", "graph", "graph.json"));
+  } catch {
+    return false;
+  }
+}
+function extractNodeName(id) {
+  const parts = id.split(":");
+  if (parts.length > 1) {
+    const fullPath = parts.slice(1).join(":");
+    return path33.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 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 null;
+  }
+}
+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);
+        }
+      }
+    }
+  }
+  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 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 = path33.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 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
+      });
+    }
+    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`;
+    }
+    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/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);
+      }
+    }
+  }
+  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);
+      }
+      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 {
+        logger.success("Baseline updated successfully.");
+      }
+      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.`
+        );
+      }
+      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/blueprint.ts
+import { Command as Command46 } from "commander";
+import * as path34 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 = path34.resolve(projectPath);
+      const outputDir = path34.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 ${path34.join(outputDir, "index.html")}`);
+    } catch (error) {
+      logger.error(
+        `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/share.ts
+import { Command as Command47 } from "commander";
+import * as fs17 from "fs";
+import * as path35 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 = path35.resolve(projectPath);
+    const manifestPath = path35.join(rootDir, MANIFEST_FILENAME);
+    if (!fs17.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 raw = fs17.readFileSync(manifestPath, "utf-8");
+      parsed = parseYaml(raw);
+    } catch (err) {
+      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(path35.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 = path35.resolve(options.output);
+    const outputPath = path35.join(outputDir, `${manifest.name}.harness-constraints.json`);
+    try {
+      await writeConfig(outputPath, bundle);
+    } catch (err) {
+      logger.error(`Failed to write bundle: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    logger.success(`Bundle written to ${outputPath}`);
+  });
+}
+
+// src/commands/install.ts
+import * as fs19 from "fs";
+import * as path37 from "path";
+import { Command as Command48 } from "commander";
+import { parse as yamlParse } from "yaml";
+
+// src/registry/tarball.ts
+import * as fs18 from "fs";
+import * as path36 from "path";
+import * as os2 from "os";
+import { execFileSync as execFileSync5 } from "child_process";
+function extractTarball(tarballBuffer) {
+  const tmpDir = fs18.mkdtempSync(path36.join(os2.tmpdir(), "harness-skill-install-"));
+  const tarballPath = path36.join(tmpDir, "package.tgz");
+  try {
+    fs18.writeFileSync(tarballPath, tarballBuffer);
+    execFileSync5("tar", ["-xzf", tarballPath, "-C", tmpDir], {
+      timeout: 3e4
+    });
+    fs18.unlinkSync(tarballPath);
+  } catch (err) {
+    cleanupTempDir(tmpDir);
+    throw new Error(
+      `Failed to extract tarball: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  return tmpDir;
+}
+function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
+  const files = fs18.readdirSync(extractedPkgDir);
+  for (const platform of platforms) {
+    const targetDir = path36.join(communityBaseDir, platform, skillName);
+    if (fs18.existsSync(targetDir)) {
+      fs18.rmSync(targetDir, { recursive: true, force: true });
+    }
+    fs18.mkdirSync(targetDir, { recursive: true });
+    for (const file of files) {
+      if (file === "package.json" || file === "node_modules") continue;
+      const srcPath = path36.join(extractedPkgDir, file);
+      const destPath = path36.join(targetDir, file);
+      const stat = fs18.statSync(srcPath);
+      if (stat.isDirectory()) {
+        fs18.cpSync(srcPath, destPath, { recursive: true });
+      } else {
+        fs18.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+function removeSkillContent(communityBaseDir, skillName, platforms) {
+  for (const platform of platforms) {
+    const targetDir = path36.join(communityBaseDir, platform, skillName);
+    if (fs18.existsSync(targetDir)) {
+      fs18.rmSync(targetDir, { recursive: true, force: true });
+    }
+  }
+}
+function cleanupTempDir(dirPath) {
+  try {
+    fs18.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];
+  }
+  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 findDependentsOf(lockfile, targetPackageName) {
+  const entry = lockfile.skills[targetPackageName];
+  if (!entry?.dependencyOf) return [];
+  return [entry.dependencyOf];
+}
+
+// src/commands/install.ts
+function validateSkillYaml(parsed) {
+  if (!parsed || typeof parsed !== "object" || !("name" in parsed) || !("version" in parsed) || !("platforms" in parsed)) {
+    throw new Error("contains invalid skill.yaml");
+  }
+  const obj = parsed;
+  if (typeof obj["name"] !== "string" || typeof obj["version"] !== "string" || !Array.isArray(obj["platforms"])) {
+    throw new Error("contains invalid skill.yaml");
+  }
+  return {
+    name: obj["name"],
+    version: obj["version"],
+    platforms: obj["platforms"],
+    depends_on: Array.isArray(obj["depends_on"]) ? obj["depends_on"] : []
+  };
+}
+async function runInstall(skillName, options) {
+  const packageName = resolvePackageName(skillName);
+  const shortName = extractSkillName(packageName);
+  const globalDir = resolveGlobalSkillsDir();
+  const skillsDir = path37.dirname(globalDir);
+  const communityBase = path37.join(skillsDir, "community");
+  const lockfilePath = path37.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);
+  const versionInfo = resolveVersion(metadata, options.version);
+  const resolvedVersion = versionInfo.version;
+  const lockfile = readLockfile(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 tarballBuffer = await downloadTarball(versionInfo.dist.tarball);
+  const extractDir = extractTarball(tarballBuffer);
+  let skillYaml;
+  try {
+    const extractedPkgDir = path37.join(extractDir, "package");
+    const skillYamlPath = path37.join(extractedPkgDir, "skill.yaml");
+    if (!fs19.existsSync(skillYamlPath)) {
+      throw new Error(`contains invalid skill.yaml: file not found in package`);
+    }
+    const rawYaml = fs19.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: null
+  };
+  let updatedLockfile = updateLockfileEntry(lockfile, packageName, entry);
+  writeLockfile(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}`);
+    await runInstall(dep, {});
+  }
+  return result;
+}
+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").action(async (skill, opts) => {
+    try {
+      const result = await runInstall(skill, opts);
+      if (result.skipped) {
+        logger.info(
+          `${result.name}@${result.version} is already installed. Use --force to reinstall.`
+        );
+      } 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) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/uninstall.ts
+import * as path38 from "path";
+import { Command as Command49 } from "commander";
+async function runUninstall(skillName, options) {
+  const packageName = resolvePackageName(skillName);
+  const shortName = extractSkillName(packageName);
+  const globalDir = resolveGlobalSkillsDir();
+  const skillsDir = path38.dirname(globalDir);
+  const communityBase = path38.join(skillsDir, "community");
+  const lockfilePath = path38.join(communityBase, "skills-lock.json");
+  const lockfile = readLockfile(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);
+  writeLockfile(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 Command49("uninstall");
+  cmd.description("Uninstall a community skill").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--force", "Remove even if other skills depend on this one").action(async (skill, opts) => {
+    try {
+      const result = await runUninstall(skill, opts);
+      if (result.warnings) {
+        for (const warning of result.warnings) {
+          logger.warn(warning);
+        }
+      }
+      logger.success(`Uninstalled ${result.name}@${result.version}`);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/orchestrator.ts
+import { Command as Command50 } from "commander";
+import * as path39 from "path";
+import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
+function createOrchestratorCommand() {
+  const orchestrator = new Command50("orchestrator");
+  orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to WORKFLOW.md", "WORKFLOW.md").action(async (opts) => {
+    const workflowPath = path39.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 Command51();
   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 +4642,13 @@ 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(createUninstallCommand());
+  program.addCommand(createOrchestratorCommand());
   return program;
 }
 
@@ -3250,5 +4659,9 @@ export {
   runQuery,
   runGraphStatus,
   runGraphExport,
+  runImpactPreview,
+  runCheckArch,
+  runInstall,
+  runUninstall,
   createProgram
 };