@harness-engineering/cli 1.1.0 → 1.2.0

package/dist/agents/skills/node_modules/.bin/yaml

@@ -6,9 +6,9 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
   exec "$basedir/node"  "$basedir/../yaml/bin.mjs" "$@"

package/dist/bin/harness.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
   createProgram
-} from "../chunk-JR7ZYYNL.js";
+} from "../chunk-IXT3KLVN.js";
+import "../chunk-3U5VZYR7.js";
 import {
   handleError
 } from "../chunk-EFZOLZFB.js";

package/dist/{validate-cross-check-N75UV2CO.js → chunk-3U5VZYR7.js}

@@ -64,6 +64,7 @@ async function runCrossCheck(options) {
   }
   return Ok(result);
 }
+
 export {
   runCrossCheck
 };

package/dist/{chunk-JR7ZYYNL.js → chunk-IXT3KLVN.js}

@@ -3,11 +3,12 @@ import {
   ExitCode,
   SkillMetadataSchema,
   createCreateSkillCommand,
+  handleError,
   logger
 } from "./chunk-EFZOLZFB.js";
 
 // src/index.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 import { VERSION } from "@harness-engineering/core";
 
 // src/commands/validate.ts
@@ -262,11 +263,11 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck } = await import("./validate-cross-check-N75UV2CO.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-LNIZ7KGZ.js");
       const cwd = process.cwd();
       const specsDir = path2.join(cwd, "docs", "specs");
       const plansDir = path2.join(cwd, "docs", "plans");
-      const crossResult = await runCrossCheck({ specsDir, plansDir, projectPath: cwd });
+      const crossResult = await runCrossCheck2({ specsDir, plansDir, projectPath: cwd });
       if (crossResult.ok && crossResult.value.warnings > 0) {
         console.log("\nCross-artifact validation:");
         for (const w of crossResult.value.planToImpl) console.log(`  ! ${w}`);
@@ -792,69 +793,78 @@ function resolveSkillsDir() {
 import { Command as Command4 } from "commander";
 import * as fs4 from "fs";
 import * as path7 from "path";
+import * as os from "os";
 import chalk2 from "chalk";
 var HARNESS_MCP_ENTRY = {
   command: "npx",
-  args: ["harness-mcp"]
+  args: ["@harness-engineering/mcp-server"]
 };
-function mergeConfig(existingPath, key) {
-  let config = {};
-  if (fs4.existsSync(existingPath)) {
-    try {
-      const content = fs4.readFileSync(existingPath, "utf-8");
-      config = JSON.parse(content);
-    } catch {
-      fs4.copyFileSync(existingPath, existingPath + ".bak");
-      config = {};
-    }
+function readJsonFile(filePath) {
+  if (!fs4.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    fs4.copyFileSync(filePath, filePath + ".bak");
+    return null;
   }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path7.dirname(filePath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  fs4.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function configureMcpServer(configPath) {
+  const config = readJsonFile(configPath) ?? {};
   if (!config.mcpServers) {
     config.mcpServers = {};
   }
-  if (config.mcpServers[key]) {
+  if (config.mcpServers["harness"]) {
     return false;
   }
-  config.mcpServers[key] = HARNESS_MCP_ENTRY;
-  const dir = path7.dirname(existingPath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  config.mcpServers["harness"] = HARNESS_MCP_ENTRY;
+  writeJsonFile(configPath, config);
+  return true;
+}
+function addGeminiTrustedFolder(cwd) {
+  const trustedPath = path7.join(os.homedir(), ".gemini", "trustedFolders.json");
+  const folders = readJsonFile(trustedPath) ?? {};
+  if (folders[cwd] === "TRUST_FOLDER") {
+    return false;
   }
-  fs4.writeFileSync(existingPath, JSON.stringify(config, null, 2) + "\n");
+  folders[cwd] = "TRUST_FOLDER";
+  writeJsonFile(trustedPath, folders);
   return true;
 }
 function setupMcp(cwd, client) {
   const configured = [];
   const skipped = [];
-  const clients = [];
+  let trustedFolder = false;
   if (client === "all" || client === "claude") {
-    clients.push({
-      name: "Claude Code",
-      configPath: path7.join(cwd, ".claude", "settings.json"),
-      key: "harness"
-    });
+    const configPath = path7.join(cwd, ".mcp.json");
+    if (configureMcpServer(configPath)) {
+      configured.push("Claude Code");
+    } else {
+      skipped.push("Claude Code");
+    }
   }
   if (client === "all" || client === "gemini") {
-    clients.push({
-      name: "Gemini CLI",
-      configPath: path7.join(cwd, ".gemini", "settings.json"),
-      key: "harness"
-    });
-  }
-  for (const c of clients) {
-    const wasAdded = mergeConfig(c.configPath, c.key);
-    if (wasAdded) {
-      configured.push(c.name);
+    const configPath = path7.join(cwd, ".gemini", "settings.json");
+    if (configureMcpServer(configPath)) {
+      configured.push("Gemini CLI");
     } else {
-      skipped.push(c.name);
+      skipped.push("Gemini CLI");
     }
+    trustedFolder = addGeminiTrustedFolder(cwd);
   }
-  return { configured, skipped };
+  return { configured, skipped, trustedFolder };
 }
 function createSetupMcpCommand() {
   return new Command4("setup-mcp").description("Configure MCP server for AI agent integration").option("--client <client>", "Client to configure (claude, gemini, all)", "all").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { configured, skipped } = setupMcp(cwd, opts.client);
+    const { configured, skipped, trustedFolder } = setupMcp(cwd, opts.client);
     if (!globalOpts.quiet) {
       console.log("");
       if (configured.length > 0) {
@@ -864,6 +874,10 @@ function createSetupMcpCommand() {
           console.log(`  ${chalk2.green("+")} ${name}`);
         }
       }
+      if (trustedFolder) {
+        console.log("");
+        logger.info("Added project to Gemini trusted folders (~/.gemini/trustedFolders.json)");
+      }
       if (skipped.length > 0) {
         console.log("");
         logger.info("Already configured:");
@@ -1689,8 +1703,8 @@ async function runAdd(componentType, name, options) {
         break;
       }
       case "skill": {
-        const { generateSkillFiles } = await import("./create-skill-4GKJZB5R.js");
-        generateSkillFiles({
+        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-4GKJZB5R.js");
+        generateSkillFiles2({
           name,
           description: `${name} skill`,
           outputDir: path13.join(cwd, "agents", "skills", "claude-code")
@@ -2704,9 +2718,430 @@ function createCheckPhaseGateCommand() {
   return command;
 }
 
+// src/commands/generate-slash-commands.ts
+import { Command as Command28 } from "commander";
+import fs17 from "fs";
+import path25 from "path";
+import os2 from "os";
+import readline2 from "readline";
+
+// src/slash-commands/normalize.ts
+import fs15 from "fs";
+import path23 from "path";
+import { parse as parse6 } from "yaml";
+
+// src/slash-commands/normalize-name.ts
+function normalizeName(skillName) {
+  let name = skillName;
+  if (name.startsWith("harness-")) {
+    name = name.slice("harness-".length);
+  }
+  name = name.replace(/-harness-/g, "-");
+  if (name.endsWith("-harness")) {
+    name = name.slice(0, -"-harness".length);
+  }
+  return name;
+}
+
+// src/slash-commands/normalize.ts
+function normalizeSkills(skillsDir, platforms) {
+  const entries = fs15.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const specs = [];
+  const nameMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const yamlPath = path23.join(skillsDir, entry.name, "skill.yaml");
+    if (!fs15.existsSync(yamlPath)) continue;
+    let raw;
+    try {
+      raw = fs15.readFileSync(yamlPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const parsed = parse6(raw);
+    const result = SkillMetadataSchema.safeParse(parsed);
+    if (!result.success) {
+      console.warn(`Skipping ${entry.name}: invalid skill.yaml`);
+      continue;
+    }
+    const meta = result.data;
+    const matchesPlatform = platforms.some((p) => meta.platforms.includes(p));
+    if (!matchesPlatform) continue;
+    const normalized = normalizeName(meta.name);
+    if (nameMap.has(normalized)) {
+      throw new Error(
+        `Name collision: skills "${nameMap.get(normalized)}" and "${meta.name}" both normalize to "${normalized}"`
+      );
+    }
+    nameMap.set(normalized, meta.name);
+    const skillMdPath = path23.join(skillsDir, entry.name, "SKILL.md");
+    const skillMdContent = fs15.existsSync(skillMdPath) ? fs15.readFileSync(skillMdPath, "utf-8") : "";
+    const skillMdRelative = path23.relative(
+      process.cwd(),
+      path23.join(skillsDir, entry.name, "SKILL.md")
+    );
+    const skillYamlRelative = path23.relative(
+      process.cwd(),
+      path23.join(skillsDir, entry.name, "skill.yaml")
+    );
+    const args = (meta.cli?.args ?? []).map((a) => ({
+      name: a.name,
+      description: a.description ?? "",
+      required: a.required ?? false
+    }));
+    const tools = [...meta.tools ?? []];
+    if (!tools.includes("Read")) {
+      tools.push("Read");
+    }
+    const contextLines = [];
+    if (meta.cognitive_mode) {
+      contextLines.push(`Cognitive mode: ${meta.cognitive_mode}`);
+    }
+    if (meta.type) {
+      contextLines.push(`Type: ${meta.type}`);
+    }
+    if (meta.state?.persistent) {
+      const files = meta.state.files?.join(", ") ?? "";
+      contextLines.push(`State: persistent${files ? ` (files: ${files})` : ""}`);
+    }
+    const objectiveLines = [meta.description];
+    if (meta.phases && meta.phases.length > 0) {
+      objectiveLines.push("");
+      objectiveLines.push("Phases:");
+      for (const phase of meta.phases) {
+        const req = phase.required !== false ? "" : " (optional)";
+        objectiveLines.push(`- ${phase.name}: ${phase.description}${req}`);
+      }
+    }
+    const executionContextLines = [];
+    if (skillMdContent) {
+      executionContextLines.push(`@${skillMdRelative}`);
+      executionContextLines.push(`@${skillYamlRelative}`);
+    }
+    const processLines = [];
+    if (meta.mcp?.tool) {
+      processLines.push(`1. Try: invoke mcp__harness__${meta.mcp.tool} with skill: "${meta.name}"`);
+      processLines.push(`2. If MCP unavailable: read SKILL.md and follow its workflow directly`);
+      processLines.push(`3. Pass through any arguments provided by the user`);
+    } else {
+      processLines.push(`1. Read SKILL.md and follow its workflow directly`);
+      processLines.push(`2. Pass through any arguments provided by the user`);
+    }
+    specs.push({
+      name: normalized,
+      namespace: "harness",
+      fullName: `harness:${normalized}`,
+      description: meta.description,
+      version: meta.version,
+      ...meta.cognitive_mode ? { cognitiveMode: meta.cognitive_mode } : {},
+      tools,
+      args,
+      skillYamlName: meta.name,
+      sourceDir: entry.name,
+      prompt: {
+        context: contextLines.join("\n"),
+        objective: objectiveLines.join("\n"),
+        executionContext: executionContextLines.join("\n"),
+        process: processLines.join("\n")
+      }
+    });
+  }
+  return specs;
+}
+
+// src/slash-commands/types.ts
+var VALID_PLATFORMS = ["claude-code", "gemini-cli"];
+var GENERATED_HEADER_CLAUDE = "<!-- Generated by harness generate-slash-commands. Do not edit. -->";
+var GENERATED_HEADER_GEMINI = "# Generated by harness generate-slash-commands. Do not edit.";
+
+// src/slash-commands/argument-hint.ts
+function buildArgumentHint(args) {
+  return args.map((arg) => arg.required ? `--${arg.name} <${arg.name}>` : `[--${arg.name} <${arg.name}>]`).join(" ");
+}
+
+// src/slash-commands/render-claude-code.ts
+function renderClaudeCode(spec) {
+  const lines = [GENERATED_HEADER_CLAUDE];
+  lines.push("---");
+  lines.push(`name: ${spec.fullName}`);
+  lines.push(`description: ${spec.description}`);
+  const hint = buildArgumentHint(spec.args);
+  if (hint) {
+    lines.push(`argument-hint: "${hint}"`);
+  }
+  if (spec.tools.length > 0) {
+    lines.push("allowed-tools:");
+    for (const tool of spec.tools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (spec.prompt.executionContext) {
+    lines.push("<execution_context>");
+    lines.push(spec.prompt.executionContext);
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  lines.push("<process>");
+  lines.push(spec.prompt.process);
+  lines.push("</process>");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/slash-commands/render-gemini.ts
+function escapeToml(content) {
+  return content.replace(/"""/g, '""\\"');
+}
+function renderGemini(spec, skillMdContent, skillYamlContent) {
+  const lines = [GENERATED_HEADER_GEMINI];
+  const safeDesc = spec.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  lines.push(`description = "${safeDesc}"`);
+  lines.push('prompt = """');
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (skillMdContent || skillYamlContent) {
+    lines.push("<execution_context>");
+    if (skillMdContent) {
+      const mdPath = spec.prompt.executionContext.split("\n")[0]?.replace(/^@/, "") ?? "";
+      lines.push(`--- SKILL.md (${mdPath}) ---`);
+      lines.push(escapeToml(skillMdContent));
+      lines.push("");
+    }
+    if (skillYamlContent) {
+      const refs = spec.prompt.executionContext.split("\n");
+      const yamlPath = (refs[1] ?? refs[0] ?? "").replace(/^@/, "");
+      lines.push(`--- skill.yaml (${yamlPath}) ---`);
+      lines.push(escapeToml(skillYamlContent));
+    }
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  const geminiProcess = spec.prompt.process.replace(
+    "read SKILL.md and follow its workflow directly",
+    "follow the SKILL.md workflow provided above directly"
+  );
+  lines.push("<process>");
+  lines.push(geminiProcess);
+  lines.push("</process>");
+  lines.push('"""');
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/slash-commands/sync.ts
+import fs16 from "fs";
+import path24 from "path";
+function computeSyncPlan(outputDir, rendered) {
+  const added = [];
+  const updated = [];
+  const removed = [];
+  const unchanged = [];
+  for (const [filename, content] of rendered) {
+    const filePath = path24.join(outputDir, filename);
+    if (!fs16.existsSync(filePath)) {
+      added.push(filename);
+    } else {
+      const existing = fs16.readFileSync(filePath, "utf-8");
+      if (existing === content) {
+        unchanged.push(filename);
+      } else {
+        updated.push(filename);
+      }
+    }
+  }
+  if (fs16.existsSync(outputDir)) {
+    const existing = fs16.readdirSync(outputDir).filter((f) => {
+      const stat = fs16.statSync(path24.join(outputDir, f));
+      return stat.isFile();
+    });
+    for (const filename of existing) {
+      if (rendered.has(filename)) continue;
+      const content = fs16.readFileSync(path24.join(outputDir, filename), "utf-8");
+      if (content.startsWith(GENERATED_HEADER_CLAUDE) || content.startsWith(GENERATED_HEADER_GEMINI)) {
+        removed.push(filename);
+      }
+    }
+  }
+  return { added, updated, removed, unchanged };
+}
+function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
+  fs16.mkdirSync(outputDir, { recursive: true });
+  for (const filename of [...plan.added, ...plan.updated]) {
+    const content = rendered.get(filename);
+    if (content !== void 0) {
+      fs16.writeFileSync(path24.join(outputDir, filename), content);
+    }
+  }
+  if (deleteOrphans) {
+    for (const filename of plan.removed) {
+      const filePath = path24.join(outputDir, filename);
+      if (fs16.existsSync(filePath)) {
+        fs16.unlinkSync(filePath);
+      }
+    }
+  }
+}
+
+// src/commands/generate-slash-commands.ts
+function resolveOutputDir(platform, opts) {
+  if (opts.output) {
+    return path25.join(opts.output, "harness");
+  }
+  if (opts.global) {
+    const home = os2.homedir();
+    return platform === "claude-code" ? path25.join(home, ".claude", "commands", "harness") : path25.join(home, ".gemini", "commands", "harness");
+  }
+  return platform === "claude-code" ? path25.join("agents", "commands", "claude-code", "harness") : path25.join("agents", "commands", "gemini-cli", "harness");
+}
+function fileExtension(platform) {
+  return platform === "claude-code" ? ".md" : ".toml";
+}
+async function confirmDeletion(files) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve13) => {
+    rl.question(`
+Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
+      rl.close();
+      resolve13(answer.toLowerCase() === "y");
+    });
+  });
+}
+function generateSlashCommands(opts) {
+  const skillsDir = opts.skillsDir || resolveSkillsDir();
+  const specs = normalizeSkills(skillsDir, opts.platforms);
+  const results = [];
+  for (const platform of opts.platforms) {
+    const outputDir = resolveOutputDir(platform, opts);
+    const ext = fileExtension(platform);
+    const useAbsolutePaths = opts.global;
+    const rendered = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      const filename = `${spec.name}${ext}`;
+      if (platform === "claude-code") {
+        const renderSpec = useAbsolutePaths ? {
+          ...spec,
+          prompt: {
+            ...spec.prompt,
+            executionContext: spec.prompt.executionContext.split("\n").map((line) => {
+              if (line.startsWith("@")) {
+                const relPath = line.slice(1);
+                return `@${path25.resolve(relPath)}`;
+              }
+              return line;
+            }).join("\n")
+          }
+        } : spec;
+        rendered.set(filename, renderClaudeCode(renderSpec));
+      } else {
+        const mdPath = path25.join(skillsDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path25.join(skillsDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs17.existsSync(mdPath) ? fs17.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs17.existsSync(yamlPath) ? fs17.readFileSync(yamlPath, "utf-8") : "";
+        rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
+      }
+    }
+    const plan = computeSyncPlan(outputDir, rendered);
+    if (!opts.dryRun) {
+      applySyncPlan(outputDir, rendered, plan, false);
+    }
+    results.push({
+      platform,
+      added: plan.added,
+      updated: plan.updated,
+      removed: plan.removed,
+      unchanged: plan.unchanged,
+      outputDir
+    });
+  }
+  return results;
+}
+async function handleOrphanDeletion(results, opts) {
+  if (opts.dryRun) return;
+  for (const result of results) {
+    if (result.removed.length === 0) continue;
+    const shouldDelete = opts.yes || await confirmDeletion(result.removed);
+    if (shouldDelete) {
+      for (const filename of result.removed) {
+        const filePath = path25.join(result.outputDir, filename);
+        if (fs17.existsSync(filePath)) {
+          fs17.unlinkSync(filePath);
+        }
+      }
+    }
+  }
+}
+function createGenerateSlashCommandsCommand() {
+  return new Command28("generate-slash-commands").description(
+    "Generate native slash commands for Claude Code and Gemini CLI from skill metadata"
+  ).option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global config directories", false).option("--output <dir>", "Custom output directory").option("--skills-dir <path>", "Skills directory to scan").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const platforms = opts.platforms.split(",").map((p) => p.trim());
+    for (const p of platforms) {
+      if (!VALID_PLATFORMS.includes(p)) {
+        throw new CLIError(
+          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
+          ExitCode.VALIDATION_FAILED
+        );
+      }
+    }
+    const generateOpts = {
+      platforms,
+      global: opts.global,
+      output: opts.output,
+      skillsDir: opts.skillsDir ?? "",
+      dryRun: opts.dryRun,
+      yes: opts.yes
+    };
+    try {
+      const results = generateSlashCommands(generateOpts);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      for (const result of results) {
+        console.log(`
+${result.platform} \u2192 ${result.outputDir}`);
+        if (result.added.length > 0) {
+          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
+        }
+        if (result.updated.length > 0) {
+          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
+        }
+        if (result.removed.length > 0) {
+          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
+        }
+        if (result.unchanged.length > 0) {
+          console.log(`  = ${result.unchanged.length} unchanged`);
+        }
+        if (opts.dryRun) {
+          console.log("  (dry run \u2014 no files written)");
+        }
+      }
+      await handleOrphanDeletion(results, { yes: opts.yes, dryRun: opts.dryRun });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command28();
+  const program = new Command29();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
@@ -2723,6 +3158,7 @@ function createProgram() {
   program.addCommand(createCheckPhaseGateCommand());
   program.addCommand(createCreateSkillCommand());
   program.addCommand(createSetupMcpCommand());
+  program.addCommand(createGenerateSlashCommandsCommand());
   return program;
 }
 
@@ -2740,5 +3176,7 @@ export {
   generateAgentsMd,
   generateCIWorkflow,
   buildPreamble,
+  runCheckPhaseGate,
+  generateSlashCommands,
   createProgram
 };