@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/skills-EDWLKAF3.js

@@ -0,0 +1,928 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/skills.ts
+import { ExitCode } from "@cleocode/contracts";
+import {
+  AgentsSkillsRealDirError,
+  skills as coreSkills,
+  restoreBundledSkillQuarantine,
+  runBundledSkillPrune,
+  runDoctorAdopt,
+  runDoctorBridge,
+  unkeepBundledSkill
+} from "@cleocode/core";
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List installed skills" },
+  args: {
+    global: {
+      type: "boolean",
+      description: "Use global skills directory"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.list",
+      {
+        scope: args.global ? "global" : "project"
+      },
+      { command: "skills", operation: "tools.skill.list" }
+    );
+  }
+});
+var searchCommand = defineCommand({
+  meta: { name: "search", description: "Search for skills" },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    mp: {
+      type: "boolean",
+      description: "Search marketplace (agentskills.in)"
+    },
+    all: {
+      type: "boolean",
+      description: "Search both local and marketplace"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.find",
+      {
+        query: args.query,
+        source: args.mp ? "skillsmp" : args.all ? "all" : "local"
+      },
+      { command: "skills", operation: "tools.skill.find" }
+    );
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Federated skill search across local, canonical, and federation peers"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    federated: {
+      type: "boolean",
+      description: "Include federation peers (OPT-IN \u2014 no network calls without this flag)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum results to return"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.federated.find",
+      {
+        query: args.query,
+        federated: !!args.federated,
+        limit: args.limit ? Number(args.limit) : void 0
+      },
+      { command: "skills", operation: "tools.skill.federated.find" }
+    );
+  }
+});
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a SKILL.md; exits non-zero with findings. Every skill is checked against the Agent Skills standard (valid YAML; name and description present, well-formed, no tags). A CLEO bundled skill (packages/skills/skills, or an installed copy of one) must also meet the CLEO frontmatter contract gate 29 enforces: metadata.version X.Y.Z, metadata.tier, metadata.install, no top-level tier/core/category, name equal to its directory."
+  },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name, skill directory, or SKILL.md path",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.verify",
+      {
+        name: args["skill-name"]
+      },
+      { command: "skills", operation: "tools.skill.verify" }
+    );
+  }
+});
+var infoCommand = defineCommand({
+  meta: { name: "info", description: "Show skill details" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to show details for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.show",
+      {
+        name: args["skill-name"]
+      },
+      { command: "skills", operation: "tools.skill.show" }
+    );
+  }
+});
+var installCommand = defineCommand({
+  meta: { name: "install", description: "Install skill to agent directory" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to install",
+      required: true
+    },
+    global: {
+      type: "boolean",
+      description: "Install globally"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.install",
+      {
+        name: args["skill-name"],
+        global: !!args.global
+      },
+      { command: "skills", operation: "tools.skill.install" }
+    );
+  }
+});
+var uninstallCommand = defineCommand({
+  meta: { name: "uninstall", description: "Uninstall a skill" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to uninstall",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.uninstall",
+      {
+        name: args["skill-name"]
+      },
+      { command: "skills", operation: "tools.skill.uninstall" }
+    );
+  }
+});
+var enableCommand = defineCommand({
+  meta: { name: "enable", description: "Enable a skill (alias for install)" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to enable",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.install",
+      {
+        name: args["skill-name"]
+      },
+      { command: "skills", operation: "tools.skill.install" }
+    );
+  }
+});
+var disableCommand = defineCommand({
+  meta: { name: "disable", description: "Disable a skill (alias for uninstall)" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to disable",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.uninstall",
+      {
+        name: args["skill-name"]
+      },
+      { command: "skills", operation: "tools.skill.uninstall" }
+    );
+  }
+});
+var refreshCommand = defineCommand({
+  meta: { name: "refresh", description: "Refresh skills cache" },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.refresh",
+      {},
+      {
+        command: "skills",
+        operation: "tools.skill.refresh"
+      }
+    );
+  }
+});
+var dispatchCommand = defineCommand({
+  meta: { name: "dispatch", description: "Resolve dispatch path for a skill" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to resolve dispatch path for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.dispatch",
+      { name: args["skill-name"] },
+      { command: "skills", operation: "tools.skill.dispatch" }
+    );
+  }
+});
+var catalogCommand = defineCommand({
+  meta: {
+    name: "catalog",
+    description: "Browse CAAMP skill catalog (protocols, profiles, resources, info)"
+  },
+  args: {
+    type: {
+      type: "string",
+      description: "Catalog type: protocols, profiles, resources, info (default: info)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum items to return"
+    },
+    offset: {
+      type: "string",
+      description: "Offset for pagination"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.catalog",
+      {
+        type: args.type ?? "info",
+        limit: args.limit ? Number(args.limit) : void 0,
+        offset: args.offset ? Number(args.offset) : void 0
+      },
+      { command: "skills", operation: "tools.skill.catalog" }
+    );
+  }
+});
+var precedenceCommand = defineCommand({
+  meta: { name: "precedence", description: "Show or resolve skill provider precedence" },
+  args: {
+    resolve: {
+      type: "string",
+      description: "Resolve precedence for a specific provider"
+    },
+    scope: {
+      type: "string",
+      description: "Scope: global or project (default: global)"
+    }
+  },
+  async run({ args }) {
+    const providerId = args.resolve;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.precedence",
+      {
+        action: providerId ? "resolve" : "show",
+        providerId,
+        scope: args.scope ?? "global"
+      },
+      { command: "skills", operation: "tools.skill.precedence" }
+    );
+  }
+});
+var depsCommand = defineCommand({
+  meta: { name: "deps", description: "Show skill dependency tree" },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill name to show dependency tree for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.dependencies",
+      { name: args["skill-name"] },
+      { command: "skills", operation: "tools.skill.dependencies" }
+    );
+  }
+});
+var doctorBridgeCommand = defineCommand({
+  meta: {
+    name: "bridge",
+    description: "Create the single ~/.agents/skills bridge symlink + remove orphan per-skill symlinks"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Back up and replace a real ~/.agents/skills directory if present"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print planned actions without mutating disk state"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (default)"
+    },
+    human: {
+      type: "boolean",
+      description: "Output in human-readable format"
+    }
+  },
+  async run({ args }) {
+    const { cliError: cliError2, cliOutput: cliOutput2 } = await import("./renderers-64OR3IWX.js");
+    try {
+      const result = await runDoctorBridge({
+        force: args.force === true,
+        dryRun: args["dry-run"] === true
+      });
+      cliOutput2(
+        { success: true, data: result },
+        { command: "skills doctor bridge", operation: "skills.doctor.bridge" }
+      );
+    } catch (error) {
+      if (error instanceof AgentsSkillsRealDirError) {
+        cliError2(
+          error.message,
+          error.code,
+          {
+            details: {
+              agentsSkillsPath: error.agentsSkillsPath,
+              entryCount: error.entryCount
+            }
+          },
+          { operation: "skills.doctor.bridge" }
+        );
+        process.exit(1);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      cliError2(message, "E_INTERNAL_ERROR", void 0, {
+        operation: "skills.doctor.bridge"
+      });
+      process.exit(1);
+    }
+  }
+});
+function buildSkillsDoctorAdoptAdapters() {
+  return {
+    loadRegisteredNames: async () => {
+      const { listSkillsBySource } = await import("@cleocode/core");
+      const rows = await Promise.all([
+        listSkillsBySource("canonical"),
+        listSkillsBySource("user"),
+        listSkillsBySource("community"),
+        listSkillsBySource("agent-created")
+      ]);
+      return new Set(rows.flat().map((r) => r.name));
+    },
+    recordRow: async (data) => {
+      const { upsertSkillRow } = await import("@cleocode/core");
+      await upsertSkillRow({
+        name: data.name,
+        sourceType: data.sourceType,
+        installPath: data.installPath,
+        installedAt: data.installedAt,
+        lifecycleState: data.lifecycleState,
+        pinned: false,
+        isAgentCreated: false
+      });
+    }
+  };
+}
+var doctorAdoptOrphansCommand = defineCommand({
+  meta: {
+    name: "adopt-orphans",
+    description: "Interactive audit of on-disk skill dirs not tracked in skills.db (canonical/user/delete/skip)"
+  },
+  args: {
+    "non-interactive": {
+      type: "boolean",
+      description: "List orphans + exit without action"
+    },
+    "auto-user-adopt": {
+      type: "boolean",
+      description: "Bulk-mark all orphans as source_type=user without prompting"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (default)"
+    },
+    human: {
+      type: "boolean",
+      description: "Output in human-readable format"
+    }
+  },
+  async run({ args }) {
+    const { cliError: cliError2, cliOutput: cliOutput2 } = await import("./renderers-64OR3IWX.js");
+    try {
+      const adapters = buildSkillsDoctorAdoptAdapters();
+      const result = await runDoctorAdopt({
+        nonInteractive: args["non-interactive"] === true,
+        autoUserAdopt: args["auto-user-adopt"] === true,
+        loadRegisteredNames: adapters.loadRegisteredNames,
+        recordRow: adapters.recordRow
+      });
+      cliOutput2(
+        { success: true, data: result },
+        { command: "skills doctor adopt-orphans", operation: "skills.doctor.adopt-orphans" }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      cliError2(message, "E_INTERNAL_ERROR", void 0, {
+        operation: "skills.doctor.adopt-orphans"
+      });
+      process.exit(1);
+    }
+  }
+});
+var doctorPruneCommand = defineCommand({
+  meta: {
+    name: "prune",
+    description: "Quarantine bundled skills CLEO no longer installs (internal/retired), only where its install ledger proves ownership"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "List what would be quarantined or kept; move nothing"
+    },
+    json: { type: "boolean", description: "Output as JSON (default)" },
+    human: { type: "boolean", description: "Output in human-readable format" }
+  },
+  async run({ args }) {
+    try {
+      const receipt = await runBundledSkillPrune({ dryRun: args["dry-run"] === true });
+      if (!receipt) {
+        cliError("bundled @cleocode/skills not found", "E_NOT_FOUND", void 0, {
+          operation: "skills.doctor.prune"
+        });
+        process.exit(4);
+      }
+      cliOutput(receipt, { command: "skills doctor prune", operation: "skills.doctor.prune" });
+    } catch (error) {
+      cliError(
+        error instanceof Error ? error.message : String(error),
+        "E_INTERNAL_ERROR",
+        void 0,
+        {
+          operation: "skills.doctor.prune"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var doctorRestoreCommand = defineCommand({
+  meta: {
+    name: "restore",
+    description: "List skill quarantines, or restore one by id (reverses cleo skills doctor prune). A restored skill is kept: prune never takes it again. --unkeep <name> hands it back to CLEO only when its files still hash exactly to the copy that was restored; a changed copy stays kept."
+  },
+  args: {
+    id: { type: "positional", required: false, description: "Quarantine id (omit to list)" },
+    unkeep: {
+      type: "string",
+      description: "Kept skill name to hand back to CLEO (only if unchanged since it was restored)"
+    },
+    json: { type: "boolean", description: "Output as JSON (default)" },
+    human: { type: "boolean", description: "Output in human-readable format" }
+  },
+  async run({ args }) {
+    try {
+      if (typeof args.unkeep === "string" && args.unkeep !== "") {
+        const outcome = await unkeepBundledSkill(args.unkeep);
+        if (!outcome.unkept) {
+          cliError(outcome.reason, ExitCode.VALIDATION_ERROR, {
+            name: "E_VALIDATION",
+            details: outcome
+          });
+          process.exit(ExitCode.VALIDATION_ERROR);
+        }
+        cliOutput(outcome, { command: "skills doctor restore", operation: "skills.doctor.unkeep" });
+        return;
+      }
+      const id = typeof args.id === "string" && args.id !== "" ? args.id : void 0;
+      const result = await restoreBundledSkillQuarantine(id);
+      cliOutput(result, { command: "skills doctor restore", operation: "skills.doctor.restore" });
+    } catch (error) {
+      cliError(
+        error instanceof Error ? error.message : String(error),
+        "E_INTERNAL_ERROR",
+        void 0,
+        {
+          operation: "skills.doctor.restore"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var statsCommand = defineCommand({
+  meta: {
+    name: "stats",
+    description: "Show skill telemetry stats: top-N usage, lifecycle / source-type breakdowns, agent-created skills"
+  },
+  args: {
+    top: {
+      type: "string",
+      description: "Top-N usage rollup limit (default 10)"
+    },
+    since: {
+      type: "string",
+      description: "Restrict the top-N rollup to the last N days (default: all-time)"
+    },
+    "by-source": {
+      type: "boolean",
+      description: "Include source-type breakdown facet"
+    },
+    "by-lifecycle": {
+      type: "boolean",
+      description: "Include lifecycle-state breakdown facet"
+    },
+    "agent-created": {
+      type: "boolean",
+      description: "Include agent-created skill list facet"
+    }
+  },
+  async run({ args }) {
+    const top = args.top ? Number(args.top) : void 0;
+    const sinceDays = args.since ? Number(args.since) : void 0;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.stats",
+      {
+        top,
+        sinceDays,
+        bySource: args["by-source"] === true,
+        byLifecycle: args["by-lifecycle"] === true,
+        agentCreated: args["agent-created"] === true
+      },
+      { command: "skills", operation: "tools.skill.stats" }
+    );
+  }
+});
+var importHermesCommand = defineCommand({
+  meta: {
+    name: "import-hermes",
+    description: "Migrate Hermes ~/.hermes/skills/.usage.json sidecars into the CLEO skills.db registry"
+  },
+  args: {
+    "hermes-home": {
+      type: "string",
+      description: "Override Hermes home directory (default: $HERMES_HOME or ~/.hermes)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print planned writes without mutating skills.db"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.import.hermes",
+      {
+        hermesHome: args["hermes-home"],
+        dryRun: args["dry-run"] === true
+      },
+      { command: "skills", operation: "tools.skill.import.hermes" }
+    );
+  }
+});
+var migrateCommand = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Migrate legacy skills (~/.local/share/agents/skills) into ~/.cleo/skills (SSoT)"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the plan without writing anything"
+    },
+    rollback: {
+      type: "boolean",
+      description: "Restore from the most recent backup tarball"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit LAFS JSON envelope (default)"
+    },
+    human: {
+      type: "boolean",
+      description: "Emit a coloured human-readable summary instead of JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.migrate",
+      {
+        dryRun: args["dry-run"] === true,
+        rollback: args.rollback === true
+      },
+      { command: "skills", operation: "tools.skill.migrate" }
+    );
+  }
+});
+var pruneTelemetryCommand = defineCommand({
+  meta: {
+    name: "prune-telemetry",
+    description: "Delete skill_usage rows older than --older-than DAYS (default 180); optional --vacuum reclaims disk space"
+  },
+  args: {
+    "older-than": {
+      type: "string",
+      description: "Age threshold in days (default 180)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print planned deletes without touching the DB"
+    },
+    vacuum: {
+      type: "boolean",
+      description: "Run VACUUM after the delete to reclaim disk space"
+    }
+  },
+  async run({ args }) {
+    const olderThanDays = args["older-than"] ? Number(args["older-than"]) : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "skill.prune.telemetry",
+      {
+        olderThanDays,
+        dryRun: args["dry-run"] === true,
+        vacuum: args.vacuum === true
+      },
+      { command: "skills", operation: "tools.skill.prune.telemetry" }
+    );
+  }
+});
+var spawnProvidersCommand = defineCommand({
+  meta: { name: "spawn-providers", description: "List providers capable of spawning subagents" },
+  args: {
+    capability: {
+      type: "string",
+      description: "Filter by capability: supportsSubagents, supportsProgrammaticSpawn, supportsInterAgentComms, supportsParallelSpawn"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.spawn.providers",
+      { capability: args.capability },
+      { command: "skills", operation: "tools.skill.spawn.providers" }
+    );
+  }
+});
+var doctorDiagnoseCommand = defineCommand({
+  meta: {
+    name: "diagnose",
+    description: "Read-only health report on skill storage, db drift, orphans, and bridge symlinks"
+  },
+  args: {
+    verbose: {
+      type: "boolean",
+      description: "Include per-skill detail in the rendered summary"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.doctor.diagnose",
+      { verbose: !!args.verbose },
+      { command: "skills", operation: "tools.skill.doctor.diagnose" }
+    );
+  }
+});
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Skill-store health checks (diagnose, bridge, adopt-orphans, prune, restore)"
+  },
+  subCommands: {
+    diagnose: doctorDiagnoseCommand,
+    bridge: doctorBridgeCommand,
+    "adopt-orphans": doctorAdoptOrphansCommand,
+    prune: doctorPruneCommand,
+    restore: doctorRestoreCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.doctor.diagnose",
+      { verbose: false },
+      { command: "skills", operation: "tools.skill.doctor.diagnose" }
+    );
+  }
+});
+var proposePatchCommand = defineCommand({
+  meta: {
+    name: "propose-patch",
+    description: "Open a PR against the cleocode repo carrying a canonical-skill patch (Sphere A)"
+  },
+  args: {
+    "skill-name": {
+      type: "positional",
+      description: "Skill identifier (e.g. ct-orchestrator)",
+      required: true
+    },
+    diff: {
+      type: "string",
+      description: "Path to a unified-diff file to apply",
+      required: true
+    },
+    title: {
+      type: "string",
+      description: 'PR title (defaults to "skill(<name>): proposed patch")'
+    },
+    body: {
+      type: "string",
+      description: "PR body markdown (defaults to a stub citing the skill + diff path)"
+    },
+    base: {
+      type: "string",
+      description: "Base branch for the PR (defaults to main)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the steps without invoking git/gh"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit LAFS JSON envelope"
+    }
+  },
+  async run({ args }) {
+    const skillName = String(args["skill-name"]);
+    const diffPath = String(args.diff);
+    const title = typeof args.title === "string" ? args.title : void 0;
+    const body = typeof args.body === "string" ? args.body : void 0;
+    const base = typeof args.base === "string" ? args.base : void 0;
+    const dryRun = args["dry-run"] === true;
+    void (args.json === true);
+    const result = await coreSkills.proposeCanonicalPatch({
+      skillName,
+      diffPath,
+      title,
+      body,
+      base,
+      dryRun
+    });
+    if (result.kind === "error") {
+      cliError(
+        result.message,
+        result.code,
+        { name: result.code },
+        { operation: "tools.skill.propose-patch" }
+      );
+      process.exit(1);
+      return;
+    }
+    if (result.kind === "dry-run") {
+      cliOutput(
+        {
+          skillName: result.skillName,
+          diffPath: result.diffPath,
+          branchName: result.branchName,
+          base: result.base,
+          steps: result.steps,
+          dryRun: true
+        },
+        {
+          command: "skills",
+          message: `[dry-run] would open PR for ${result.skillName} on branch ${result.branchName}`,
+          operation: "tools.skill.propose-patch"
+        }
+      );
+      return;
+    }
+    cliOutput(
+      {
+        skillName: result.skillName,
+        prUrl: result.prUrl,
+        branchName: result.branchName,
+        base: result.base
+      },
+      {
+        command: "skills",
+        message: `Opened PR ${result.prUrl}`,
+        operation: "tools.skill.propose-patch"
+      }
+    );
+  }
+});
+var skillsCommand = defineCommand({
+  meta: { name: "skills", description: "Skill management: list, search, validate, info, install" },
+  subCommands: {
+    list: listCommand,
+    search: searchCommand,
+    find: findCommand,
+    validate: validateCommand,
+    info: infoCommand,
+    install: installCommand,
+    uninstall: uninstallCommand,
+    enable: enableCommand,
+    disable: disableCommand,
+    refresh: refreshCommand,
+    dispatch: dispatchCommand,
+    catalog: catalogCommand,
+    precedence: precedenceCommand,
+    deps: depsCommand,
+    "spawn-providers": spawnProvidersCommand,
+    doctor: doctorCommand,
+    "propose-patch": proposePatchCommand,
+    stats: statsCommand,
+    "import-hermes": importHermesCommand,
+    migrate: migrateCommand,
+    "prune-telemetry": pruneTelemetryCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.list",
+      {
+        scope: "project"
+      },
+      { command: "skills", operation: "tools.skill.list" }
+    );
+  }
+});
+export {
+  skillsCommand
+};
+//# sourceMappingURL=skills-EDWLKAF3.js.map