@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-EXKUF426.js

@@ -0,0 +1,1801 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  normalizedSkillHash
+} from "./chunk-DNCE23JJ.js";
+import {
+  readRootEntries,
+  splitYamlFrontmatter,
+  stringField
+} from "./chunk-YJCCMYYT.js";
+import {
+  LIBRARY_PROVIDES_LIMITS,
+  enabledPluginResourceRoots,
+  installPlugin,
+  isLibraryKind,
+  isLibraryResourceKind,
+  isPluginId,
+  listInstalledPlugins,
+  pluginBaseDir,
+  pluginResourcePath,
+  readPluginInstallRecord,
+  readPluginManifest,
+  removePlugin,
+  resolvePackageReferences
+} from "./chunk-6UJ7RDI7.js";
+import {
+  isAgentAudience,
+  isAgentCapabilityClass,
+  isAgentCategory,
+  isAgentLatencyClass,
+  isAgentProduct,
+  isAgentProjectContextTier,
+  parseResultContract
+} from "./chunk-ARRUMZ7X.js";
+import {
+  extensionContentDigest,
+  isSemanticVersion
+} from "./chunk-XW2UZICE.js";
+import {
+  readSettings,
+  updateSettings
+} from "./chunk-PGEFOTJB.js";
+import {
+  warnLegacyNaming
+} from "./chunk-DVNAPPXU.js";
+import {
+  INTEROP_AGENT_KINDS,
+  interopSourceRank
+} from "./chunk-5EQO5NWP.js";
+import {
+  ToolNames
+} from "./chunk-WLHX3MM5.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  buildSafeToolEnv,
+  runCommandVector
+} from "./chunk-GJ24ODAX.js";
+import {
+  withStateFileLockSync
+} from "./chunk-DVJL77SO.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/agents/recipe.ts
+init_esm_shims();
+import path from "node:path";
+var AGENT_BUDGET_KEYS = ["toolCalls", "readReserve", "synthesis", "maximum"];
+function parseAgentBudgetPhase(value, prefix, relationTarget) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${prefix} must be a non-null YAML object`);
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    if (key !== "toolCalls" && key !== "readReserve") throw new Error(`${prefix}.${key} is unknown`);
+  }
+  for (const key of ["toolCalls", "readReserve"]) {
+    if (!Object.hasOwn(record, key)) throw new Error(`${prefix}.${key} is required`);
+  }
+  const toolCalls = record.toolCalls;
+  if (typeof toolCalls !== "number" || !Number.isSafeInteger(toolCalls)) {
+    throw new Error(`${prefix}.toolCalls must be a finite safe integer`);
+  }
+  if (toolCalls <= 0) throw new Error(`${prefix}.toolCalls must be greater than 0`);
+  const readReserve = record.readReserve;
+  if (typeof readReserve !== "number" || !Number.isSafeInteger(readReserve)) {
+    throw new Error(`${prefix}.readReserve must be a finite safe integer`);
+  }
+  if (readReserve < 0) throw new Error(`${prefix}.readReserve must be greater than or equal to 0`);
+  if (readReserve >= toolCalls) throw new Error(`${prefix}.readReserve must be less than ${relationTarget}`);
+  return { toolCalls, readReserve };
+}
+function parseAgentBudget(value, sourcePath) {
+  if (value === void 0) return void 0;
+  const prefix = `agent budget: ${sourcePath}: budget`;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${prefix} must be a non-null YAML object`);
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    if (!AGENT_BUDGET_KEYS.includes(key)) {
+      throw new Error(`${prefix}.${key} is unknown`);
+    }
+  }
+  for (const key of ["toolCalls", "readReserve", "synthesis"]) {
+    if (!Object.hasOwn(record, key)) throw new Error(`${prefix}.${key} is required`);
+  }
+  const phase = parseAgentBudgetPhase(
+    { toolCalls: record.toolCalls, readReserve: record.readReserve },
+    prefix,
+    "budget.toolCalls"
+  );
+  const synthesis = record.synthesis;
+  if (typeof synthesis !== "boolean") throw new Error(`${prefix}.synthesis must be a boolean`);
+  const maximum = record.maximum === void 0 ? void 0 : parseAgentBudgetPhase(record.maximum, `${prefix}.maximum`, "budget.maximum.toolCalls");
+  if (maximum !== void 0) {
+    if (maximum.toolCalls < phase.toolCalls) {
+      throw new Error(`${prefix}.maximum.toolCalls must be greater than or equal to budget.toolCalls`);
+    }
+    if (maximum.readReserve < phase.readReserve) {
+      throw new Error(`${prefix}.maximum.readReserve must be greater than or equal to budget.readReserve`);
+    }
+  }
+  return { ...phase, synthesis, ...maximum === void 0 ? {} : { maximum } };
+}
+function recipeIdFromPath(absPath, rootDir) {
+  const resolvedRoot = path.resolve(rootDir);
+  const resolvedPath = path.resolve(absPath);
+  const relPath = path.relative(resolvedRoot, resolvedPath);
+  if (relPath === "" || relPath.startsWith("..") || path.isAbsolute(relPath)) {
+    throw new Error(`recipe: path must live under rootDir (${resolvedPath} not under ${resolvedRoot})`);
+  }
+  if (path.dirname(relPath) !== ".") {
+    throw new Error(`recipe: recipes must live directly under rootDir (${resolvedPath})`);
+  }
+  if (path.extname(relPath) !== ".md") {
+    throw new Error(`recipe: recipe files must end in .md (${resolvedPath})`);
+  }
+  const id = path.basename(relPath, ".md");
+  if (id === "") {
+    throw new Error(`recipe: recipe filename must not be empty (${resolvedPath})`);
+  }
+  return id;
+}
+
+// src/domains/agents/recipe-schema.ts
+init_esm_shims();
+var RECIPE_KEYS = [
+  "version",
+  "name",
+  "description",
+  "tools",
+  "skills",
+  "audience",
+  "category",
+  "capabilityClass",
+  "latencyClass",
+  "projectContextTier",
+  "budget",
+  "resultContract",
+  "tags"
+];
+var OPTIONAL_RECIPE_KEYS = ["product"];
+var ALL_RECIPE_KEYS = [...RECIPE_KEYS, ...OPTIONAL_RECIPE_KEYS];
+function requiredString(value, path6) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new Error(`agent recipe: ${path6} must be a non-empty string`);
+  return value;
+}
+function requiredStringArray(value, path6) {
+  if (!Array.isArray(value)) throw new Error(`agent recipe: ${path6} must be an array of strings`);
+  const entries = value.map((entry, index) => requiredString(entry, `${path6}[${index}]`));
+  if (new Set(entries).size !== entries.length) throw new Error(`agent recipe: ${path6} must not contain duplicates`);
+  return entries;
+}
+function enumValue(value, path6, predicate) {
+  if (!predicate(value)) throw new Error(`agent recipe: ${path6} has an unsupported value`);
+  return value;
+}
+function parseAudience(value, source, filepath) {
+  const audience = enumValue(value, `${filepath}: audience`, isAgentAudience);
+  if (source === "builtin") {
+    if (audience === "custom") {
+      throw new Error(`agent recipe: ${filepath}: a builtin recipe must not declare audience 'custom'`);
+    }
+    return audience;
+  }
+  if (audience !== "custom") {
+    throw new Error(
+      `agent recipe: ${filepath}: a ${source} recipe must declare audience 'custom', not '${audience}'; audience follows where the recipe was discovered and cannot be claimed in frontmatter`
+    );
+  }
+  return audience;
+}
+function parseTools(value, filepath) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`agent recipe: ${filepath}: tools must be a { required, optional } object`);
+  }
+  const record = value;
+  if (Object.keys(record).some((key) => key !== "required" && key !== "optional")) {
+    throw new Error(`agent recipe: ${filepath}: tools has an unknown key`);
+  }
+  if (!("required" in record) || !("optional" in record)) {
+    throw new Error(`agent recipe: ${filepath}: tools.required and tools.optional are required`);
+  }
+  if (!Array.isArray(record.required) || !Array.isArray(record.optional)) {
+    throw new Error(`agent recipe: ${filepath}: tools.required and tools.optional must be arrays`);
+  }
+  const required = record.required.map((entry, index) => {
+    const entryPath = `${filepath}: tools.required[${index}]`;
+    if (typeof entry === "string") return requiredString(entry, entryPath);
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`agent recipe: ${entryPath} must be a tool name or { anyOf: [...] }`);
+    }
+    const group = entry;
+    if (Object.keys(group).length !== 1 || !("anyOf" in group)) {
+      throw new Error(`agent recipe: ${entryPath} must contain only anyOf`);
+    }
+    const anyOf = requiredStringArray(group.anyOf, `${entryPath}.anyOf`);
+    if (anyOf.length === 0) throw new Error(`agent recipe: ${entryPath}.anyOf must not be empty`);
+    return { anyOf };
+  });
+  const optional = requiredStringArray(record.optional, `${filepath}: tools.optional`);
+  const tools = [
+    ...required.flatMap((requirement) => typeof requirement === "string" ? [requirement] : requirement.anyOf),
+    ...optional
+  ];
+  if (new Set(tools).size !== tools.length)
+    throw new Error(`agent recipe: ${filepath}: tools contains duplicate requirements`);
+  return { tools, toolRequirements: { required, optional } };
+}
+function parseAgentRecipeSchema(input) {
+  const { frontmatter, filepath } = input;
+  for (const key of Object.keys(frontmatter)) {
+    if (!ALL_RECIPE_KEYS.includes(key)) {
+      throw new Error(`agent recipe: ${filepath}: unknown key '${key}'`);
+    }
+  }
+  for (const key of RECIPE_KEYS) {
+    if (!(key in frontmatter)) throw new Error(`agent recipe: ${filepath}: ${key} is required`);
+  }
+  if (frontmatter.version !== 1) throw new Error(`agent recipe: ${filepath}: version must be the supported integer 1`);
+  if (input.body.trim().length === 0) throw new Error(`agent recipe: ${filepath}: persona body must not be empty`);
+  const parsedTools = parseTools(frontmatter.tools, filepath);
+  const budget = parseAgentBudget(frontmatter.budget, filepath);
+  if (budget === void 0) throw new Error(`agent recipe: ${filepath}: budget is required`);
+  return {
+    version: 1,
+    id: input.id,
+    name: requiredString(frontmatter.name, `${filepath}: name`),
+    description: requiredString(frontmatter.description, `${filepath}: description`),
+    tools: parsedTools.tools,
+    toolRequirements: parsedTools.toolRequirements,
+    skills: requiredStringArray(frontmatter.skills, `${filepath}: skills`),
+    boundSkillPaths: [],
+    audience: parseAudience(frontmatter.audience, input.source, filepath),
+    category: enumValue(frontmatter.category, `${filepath}: category`, isAgentCategory),
+    capabilityClass: enumValue(
+      frontmatter.capabilityClass,
+      `${filepath}: capabilityClass`,
+      isAgentCapabilityClass
+    ),
+    latencyClass: enumValue(
+      frontmatter.latencyClass,
+      `${filepath}: latencyClass`,
+      isAgentLatencyClass
+    ),
+    projectContextTier: enumValue(
+      frontmatter.projectContextTier,
+      `${filepath}: projectContextTier`,
+      isAgentProjectContextTier
+    ),
+    budget,
+    resultContract: parseResultContract(frontmatter.resultContract, filepath),
+    // Optional, but not lenient. A misspelled product silently costs the run
+    // the delivery tools its reserve window was supposed to keep, and the
+    // only symptom is a blocked tool call deep in a dispatch log.
+    ...frontmatter.product === void 0 ? {} : { product: enumValue(frontmatter.product, `${filepath}: product`, isAgentProduct) },
+    tags: requiredStringArray(frontmatter.tags, `${filepath}: tags`),
+    source: input.source,
+    filepath,
+    body: input.body
+  };
+}
+
+// src/domains/plugins/catalog.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path2 from "node:path";
+function parsePluginGithubSource(source) {
+  const match = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/tree\/([A-Za-z0-9_.-]+)(?:\/(.*?))?\/?$/.exec(source);
+  if (!match?.[1] || !match[2] || !match[3]) return void 0;
+  const subdir = match[4] ?? "";
+  if (subdir.split("/").some((part) => part === ".." || part === ".") || subdir.includes("\\") || subdir.includes("\0"))
+    return void 0;
+  return { url: `https://github.com/${match[1]}/${match[2]}.git`, ref: match[3], subdir };
+}
+function pluginLocalPath(source, cwd = process.cwd()) {
+  return path2.resolve(cwd, source.startsWith("~/") ? path2.join(homedir(), source.slice(2)) : source);
+}
+function fetchPluginSource(source, cwd = process.cwd()) {
+  const local = pluginLocalPath(source, cwd);
+  if (existsSync(local)) return { root: local, cleanup: () => {
+  } };
+  const remote = parsePluginGithubSource(source);
+  if (!remote)
+    throw new Error(
+      `unsupported plugin source: ${source}; use a local directory or https://github.com/owner/repo/tree/ref/path`
+    );
+  const temp = mkdtempSync(path2.join(tmpdir(), "clio-coder-plugin-"));
+  const cleanup = () => rmSync(temp, { recursive: true, force: true });
+  try {
+    execFileSync(
+      "git",
+      ["-c", "core.hooksPath=/dev/null", "clone", "--depth", "1", "--branch", remote.ref, "--", remote.url, temp],
+      {
+        stdio: "pipe",
+        timeout: 12e4,
+        maxBuffer: 1e6,
+        env: buildSafeToolEnv({ GIT_TERMINAL_PROMPT: "0", GIT_CONFIG_NOSYSTEM: "1" })
+      }
+    );
+    const root = path2.join(temp, remote.subdir);
+    if (!existsSync(root) || !statSync(root).isDirectory())
+      throw new Error(`plugin source has no directory ${remote.subdir || "."}: ${source}`);
+    const relative = path2.relative(realpathSync(temp), realpathSync(root));
+    if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative))
+      throw new Error("plugin source escapes repository");
+    if (!remote.subdir) rmSync(path2.join(temp, ".git"), { recursive: true, force: true });
+    return { root, cleanup };
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+var PROVIDED_NAME = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+function providedResources(value, name, diagnostics) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > LIBRARY_PROVIDES_LIMITS.entries) {
+    diagnostics.push(`library index provides ignored (not a bounded list): ${name}`);
+    return void 0;
+  }
+  const hints = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of value) {
+    const item = raw && typeof raw === "object" ? raw : void 0;
+    if (!item || !isLibraryResourceKind(item.kind) || typeof item.name !== "string" || item.name.length > LIBRARY_PROVIDES_LIMITS.name || !PROVIDED_NAME.test(item.name) || item.description !== void 0 && (typeof item.description !== "string" || item.description.length > LIBRARY_PROVIDES_LIMITS.description)) {
+      diagnostics.push(`library index provides ignored (malformed hint): ${name}`);
+      return void 0;
+    }
+    const key = `${item.kind}:${item.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    hints.push({
+      kind: item.kind,
+      name: item.name,
+      ...typeof item.description === "string" ? { description: item.description } : {}
+    });
+  }
+  return hints;
+}
+function readPluginCatalog(file, diagnostics) {
+  if (!existsSync(file)) return [];
+  try {
+    const parsed = (0, import_yaml.parse)(readFileSync(file, "utf8"));
+    const rows = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.entries) ? parsed.entries : void 0;
+    if (!rows) throw new Error("library index must be a list or contain an entries list");
+    return rows.flatMap((row) => {
+      if (!row || typeof row !== "object") {
+        diagnostics.push(`library index entry malformed: ${file}`);
+        return [];
+      }
+      const item = row;
+      if (!isLibraryKind(item.kind) || typeof item.name !== "string" || !isPluginId(item.name) || typeof item.description !== "string" || typeof item.sourceUrl !== "string" || item.sourceUrl.trim().length === 0 || !isSemanticVersion(item.version) || typeof item.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256)) {
+        diagnostics.push(
+          `library index entry requires name, description, sourceUrl, version, and full-tree sha256: ${String(item.name ?? file)}`
+        );
+        return [];
+      }
+      if (item.requires !== void 0 && (!Array.isArray(item.requires) || item.requires.some((ref) => typeof ref !== "string"))) {
+        diagnostics.push(`library_requirement_malformed: ${item.name}`);
+        return [];
+      }
+      const remote = /^(?:[a-z][a-z0-9+.-]*:\/\/|git@)/i.test(item.sourceUrl);
+      if (remote && !parsePluginGithubSource(item.sourceUrl)) {
+        diagnostics.push(`unsupported library index source: ${item.sourceUrl}`);
+        return [];
+      }
+      const provides = providedResources(item.provides, item.name, diagnostics);
+      return [
+        {
+          kind: item.kind,
+          name: item.name,
+          description: item.description,
+          sourceUrl: remote ? item.sourceUrl : path2.resolve(path2.dirname(file), item.sourceUrl),
+          version: item.version,
+          sha256: item.sha256,
+          origin: "catalog",
+          ...typeof item.category === "string" ? { category: item.category } : {},
+          ...["pass", "warn", "fail", "unknown"].includes(String(item.audit)) ? { audit: item.audit } : {},
+          ...Array.isArray(item.triggers) ? { triggers: item.triggers.filter((value) => typeof value === "string") } : {},
+          ...Array.isArray(item.requires) ? { requires: item.requires } : {},
+          ...provides ? { provides } : {},
+          index: path2.resolve(file)
+        }
+      ];
+    });
+  } catch (error) {
+    diagnostics.push(`library index unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+function bundledLibraryIndexPath() {
+  return path2.join(resolvePackageRoot(), "library", "registry.yaml");
+}
+function bundledPluginCatalog(diagnostics) {
+  try {
+    return readPluginCatalog(bundledLibraryIndexPath(), diagnostics);
+  } catch (error) {
+    diagnostics.push(`library index unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+
+// src/domains/resources/library.ts
+init_esm_shims();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
+function catalogPath() {
+  const configured = readSettings().integrations.library.catalog;
+  return path3.resolve(configured ?? path3.join(clioConfigDir(), "library.yaml"));
+}
+function parseCatalog(filePath, diagnostics) {
+  return readPluginCatalog(filePath, diagnostics).map((entry) => ({ ...entry, origin: "index" }));
+}
+function displayInstallRecord(id, options, diagnostics) {
+  try {
+    return readPluginInstallRecord(id, options);
+  } catch (error) {
+    const message = `package state unavailable (${options.scope}:${id}): ${error instanceof Error ? error.message : String(error)}`;
+    if (!diagnostics.includes(message)) diagnostics.push(message);
+    return void 0;
+  }
+}
+function libraryEntryRef(entry) {
+  return `${entry.kind}:${entry.name}`;
+}
+function discoverLibrary(options = {}) {
+  const diagnostics = [];
+  const bundledPlugins = bundledPluginCatalog(diagnostics);
+  const privatePath = catalogPath();
+  const primary = options.catalog ? parseCatalog(path3.resolve(options.catalog), diagnostics) : [];
+  const privateEntries = parseCatalog(privatePath, diagnostics);
+  const byRef = /* @__PURE__ */ new Map();
+  for (const entry of [
+    ...bundledPlugins,
+    ...privateEntries,
+    ...parseCatalog(path3.join(options.cwd ?? process.cwd(), ".clio-coder", "library.yaml"), diagnostics),
+    ...primary
+  ])
+    byRef.set(libraryEntryRef(entry), entry);
+  for (const plugin of listInstalledPlugins(options.cwd ?? process.cwd(), { all: true })) {
+    const ref = `${plugin.kind ?? "plugin"}:${plugin.id}`;
+    if (byRef.has(ref)) continue;
+    const record = displayInstallRecord(
+      plugin.id,
+      { ...options.cwd ? { cwd: options.cwd } : {}, scope: plugin.scope },
+      diagnostics
+    );
+    byRef.set(ref, {
+      kind: plugin.kind ?? "plugin",
+      name: plugin.id,
+      version: plugin.version,
+      description: plugin.description,
+      sourceUrl: record?.source ?? plugin.rootPath,
+      origin: "installed"
+    });
+  }
+  const refusals = {};
+  const entries = [...byRef.values()];
+  for (const entry of entries) {
+    try {
+      resolveLibraryRequirements(entry, [...byRef.values()]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      refusals[libraryEntryRef(entry)] = message;
+      if (!diagnostics.includes(message)) diagnostics.push(message);
+    }
+  }
+  return {
+    entries: entries.sort((a, b) => libraryEntryRef(a).localeCompare(libraryEntryRef(b))),
+    diagnostics,
+    refusals
+  };
+}
+var REQUIREMENT_PATTERN = /^(skill|agent|prompt|fleet|plugin):([A-Za-z0-9][A-Za-z0-9._-]*)$/;
+function resolveLibraryRequirements(entry, catalog) {
+  const byRef = new Map(catalog.map((item) => [libraryEntryRef(item), item]));
+  const ordered = [];
+  const visiting = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (current) => {
+    const currentRef = libraryEntryRef(current);
+    if (visited.has(currentRef)) return;
+    const cycleAt = visiting.indexOf(currentRef);
+    if (cycleAt >= 0)
+      throw new Error(`library_requirement_cycle: ${[...visiting.slice(cycleAt), currentRef].join(" -> ")}`);
+    visiting.push(currentRef);
+    for (const requirement of current.requires ?? []) {
+      if (!REQUIREMENT_PATTERN.test(requirement)) throw new Error("library_requirement_malformed");
+      const dependency = byRef.get(requirement);
+      if (!dependency) throw new Error(`library_requirement_missing: ${requirement}`);
+      visit(dependency);
+    }
+    visiting.pop();
+    visited.add(currentRef);
+    ordered.push(current);
+  };
+  visit(entry);
+  return ordered;
+}
+function resolveInstalledLibraryEntry(ref, options = {}) {
+  const copies = listInstalledPlugins(options.cwd ?? process.cwd(), { ...options, all: true }).filter((item2) => ref.includes(":") ? `${item2.kind ?? "plugin"}:${item2.id}` === ref : item2.id === ref).sort((a, b) => Number(b.scope === "project") - Number(a.scope === "project"));
+  const item = copies[0];
+  if (!item) throw new Error(`package not installed: ${ref}`);
+  const saved = readPluginInstallRecord(item.id, { ...options, scope: item.scope });
+  return {
+    scope: item.scope,
+    kind: item.kind ?? "plugin",
+    name: item.id,
+    description: item.description,
+    version: item.version,
+    sourceUrl: saved?.source ?? item.rootPath,
+    origin: "installed",
+    ...item.manifest?.clio.requires ? { requires: item.manifest.clio.requires } : {}
+  };
+}
+function registerLibraryPackage(source, options = {}) {
+  const local = pluginLocalPath(source, options.cwd);
+  const candidate = readPluginManifest(local);
+  if (!candidate.valid || !candidate.manifest || !candidate.contentDigest)
+    throw new Error(candidate.diagnostics.map((item) => item.message).join("; "));
+  const manifest = candidate.manifest;
+  const entry = {
+    kind: manifest.clio.kind ?? "plugin",
+    name: manifest.name,
+    description: manifest.description ?? "",
+    ...manifest.version ? { version: manifest.version } : {},
+    sha256: candidate.contentDigest,
+    sourceUrl: local,
+    origin: "index",
+    ...manifest.clio.requires ? { requires: manifest.clio.requires } : {}
+  };
+  const file = options.scope === "project" ? path3.join(options.cwd ?? process.cwd(), ".clio-coder", "library.yaml") : catalogPath();
+  withStateFileLockSync(file, () => {
+    const diagnostics = [];
+    const before = existsSync2(file) ? readFileSync2(file, "utf8") : void 0;
+    const entries = readPluginCatalog(file, diagnostics);
+    if (diagnostics.length) throw new Error(diagnostics.join("; "));
+    const previous = entries.find((item) => item.name === entry.name);
+    if (previous && !options.force)
+      throw new Error(`package already registered: ${entry.name}; use --force to replace its pin`);
+    const next = [...entries.filter((item) => item.name !== entry.name), entry].sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+    if ((existsSync2(file) ? readFileSync2(file, "utf8") : void 0) !== before)
+      throw new Error("library index changed during registration");
+    safeResourceWrite(file, (0, import_yaml2.stringify)({ entries: next.map(({ origin: _origin, index: _index, ...item }) => item) }), {
+      encoding: "utf8"
+    });
+  });
+  return entry;
+}
+function libraryWorkspace(options = {}) {
+  const discovery = discoverLibrary(options);
+  const installed = listInstalledPlugins(options.cwd ?? process.cwd(), { ...options, all: true });
+  return {
+    ...discovery,
+    entries: discovery.entries.map((entry) => ({
+      ...entry,
+      installed: installed.filter((item) => item.id === entry.name && (item.kind ?? "plugin") === entry.kind).map((item) => ({
+        ...item,
+        origin: displayInstallRecord(item.id, { ...options, scope: item.scope }, discovery.diagnostics)?.origin
+      }))
+    }))
+  };
+}
+function installedPlugin(entry, options = {}) {
+  return listInstalledPlugins(options.cwd ?? process.cwd(), {
+    all: true,
+    ...options.scope ? { scope: options.scope } : {}
+  }).filter((plugin) => plugin.id === entry.name && (plugin.kind ?? "plugin") === entry.kind).sort((left, right) => Number(right.scope === "project") - Number(left.scope === "project"))[0];
+}
+function libraryInstallPath(entry, options = {}) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(entry.name)) throw new Error(`invalid library entry name: ${entry.name}`);
+  return installedPlugin(entry, options)?.rootPath ?? path3.join(pluginBaseDir(options.scope ?? "user", options.cwd ?? process.cwd()), entry.name);
+}
+function libraryEntryInstalled(entry, options = {}) {
+  return installedPlugin(entry, options) !== void 0;
+}
+function libraryEntryPin(entry, options = {}) {
+  const plugin = installedPlugin(entry, options);
+  if (!plugin) return void 0;
+  const record = displayInstallRecord(entry.name, { ...options, scope: plugin.scope }, []);
+  return record ? { sha256: record.contentDigest, sourceUrl: record.source } : void 0;
+}
+function classifyLibraryRequirements(entry, catalog, options = {}) {
+  const ordered = resolveLibraryRequirements(entry, catalog).slice(0, -1);
+  const inactive = ordered.filter(
+    (requirement) => libraryEntryInstalled(requirement, options) && !listInstalledPlugins(options.cwd ?? process.cwd(), options).some(
+      (plugin) => plugin.id === requirement.name && (plugin.kind ?? "plugin") === requirement.kind && plugin.loadable
+    )
+  );
+  const inactiveRefs = new Set(inactive.map(libraryEntryRef));
+  const satisfied = ordered.filter(
+    (requirement) => libraryEntryInstalled(requirement, options) && !inactiveRefs.has(libraryEntryRef(requirement))
+  );
+  const satisfiedRefs = new Set(satisfied.map(libraryEntryRef));
+  return {
+    ordered,
+    satisfied,
+    ...inactive.length ? { inactive } : {},
+    unsatisfied: ordered.filter((requirement) => !satisfiedRefs.has(libraryEntryRef(requirement)))
+  };
+}
+function planLibraryInstall(entry, options = {}) {
+  const fetched = fetchPluginSource(entry.sourceUrl, options.cwd);
+  try {
+    const candidate = readPluginManifest(fetched.root);
+    if (!candidate.valid || !candidate.manifest)
+      throw new Error(`invalid plugin: ${candidate.diagnostics.map((item) => item.message).join("; ")}`);
+    if ((candidate.manifest.clio.kind ?? "plugin") !== entry.kind)
+      throw new Error(`package kind mismatch: expected ${entry.kind}`);
+    if (candidate.manifest.name !== entry.name)
+      throw new Error(`plugin identity mismatch: expected ${entry.name}, found ${candidate.manifest.name}`);
+    if (entry.version && candidate.manifest.version !== entry.version)
+      throw new Error(`plugin version mismatch: expected ${entry.version}, found ${candidate.manifest.version}`);
+    const declaredRequirements = candidate.manifest.clio.requires ?? [];
+    if (JSON.stringify([...declaredRequirements].sort()) !== JSON.stringify([...entry.requires ?? []].sort()))
+      throw new Error(
+        `library_requirement_mismatch: ${entry.name}; index and manifest must declare the same requirements`
+      );
+    const sha2562 = extensionContentDigest(fetched.root);
+    if (entry.sha256 && sha2562 !== entry.sha256) throw new Error(`plugin_pin_mismatch: ${entry.name}`);
+    return {
+      entry: { ...entry, ...candidate.manifest.version ? { version: candidate.manifest.version } : {} },
+      path: path3.join(pluginBaseDir(options.scope ?? "user", options.cwd ?? process.cwd()), entry.name),
+      sha256: sha2562,
+      sourceRoot: fetched.root,
+      cleanup: fetched.cleanup,
+      ...options
+    };
+  } catch (error) {
+    fetched.cleanup();
+    throw error;
+  }
+}
+function releaseLibraryPlan(plan) {
+  plan.cleanup?.();
+}
+function commitLibraryInstallPlan(plan) {
+  if (existsSync2(plan.path) && !plan.force) throw new Error(`library destination already exists: ${plan.path}`);
+  if (!plan.sourceRoot) throw new Error("plugin install plan has no staged source");
+  if (plan.expectedInstalledDigest && extensionContentDigest(plan.path) !== plan.expectedInstalledDigest)
+    throw new Error(`plugin_destination_changed: ${plan.entry.name}`);
+  const expect = plan.expect ?? (plan.expectedInstalledDigest ? {
+    copies: [
+      {
+        scope: plan.scope ?? "user",
+        id: plan.entry.name,
+        partial: true,
+        recorded: true,
+        tree: plan.expectedInstalledDigest
+      }
+    ]
+  } : void 0);
+  return installPlugin(plan.sourceRoot, {
+    ...plan.cwd ? { cwd: plan.cwd } : {},
+    scope: plan.scope ?? "user",
+    force: plan.force ?? false,
+    expectedDigest: plan.sha256,
+    expectedId: plan.entry.name,
+    expectedKind: plan.entry.kind,
+    ...plan.entry.version ? { expectedVersion: plan.entry.version } : {},
+    ...expect ? { expect } : {},
+    origin: {
+      kind: plan.entry.origin === "catalog" || plan.entry.origin === "index" ? "catalog" : parsePluginGithubSource(plan.entry.sourceUrl) ? "github" : "local",
+      source: plan.entry.sourceUrl
+    }
+  });
+}
+function installLibraryPlan(plan) {
+  let recovery;
+  try {
+    const result = commitLibraryInstallPlan(plan);
+    if (!result.plugin || result.diagnostics.some((item) => item.type === "error"))
+      throw new Error(
+        `${result.diagnostics.map((item) => item.message).join("; ") || "plugin install failed"}${result.recovery ? `; recovery: ${JSON.stringify(result.recovery)}` : ""}`
+      );
+    recovery = result.recovery;
+    return recovery ? { recovery } : {};
+  } finally {
+    releaseLibraryPlan(plan);
+  }
+}
+function resolveLibraryPackage(source, options = {}) {
+  const local = pluginLocalPath(source, options.cwd);
+  if (existsSync2(local)) {
+    const candidate = readPluginManifest(local);
+    if (!candidate.valid || !candidate.manifest)
+      throw new Error(`invalid plugin: ${candidate.diagnostics.map((item) => item.message).join("; ")}`);
+    return {
+      kind: candidate.manifest.clio.kind ?? "plugin",
+      name: candidate.manifest.name,
+      ...candidate.manifest.clio.requires ? { requires: candidate.manifest.clio.requires } : {},
+      description: candidate.manifest.description ?? "",
+      ...candidate.manifest.version ? { version: candidate.manifest.version } : {},
+      sourceUrl: local,
+      origin: "installed"
+    };
+  }
+  const matches = discoverLibrary(options).entries.filter(
+    (item) => source.includes(":") ? libraryEntryRef(item) === source : item.name === source
+  );
+  if (matches.length > 1) throw new Error(`ambiguous package: ${source}; use kind:name`);
+  const entry = matches[0];
+  if (entry) return entry;
+  if (parsePluginGithubSource(source))
+    throw new Error("remote plugin installation requires a catalog entry with version and full-tree sha256 pin");
+  throw new Error(`plugin source is neither an existing local directory nor a catalog entry: ${source}`);
+}
+function planLibraryUpdate(id, options = {}) {
+  const identity = resolveInstalledLibraryEntry(id, options);
+  const plugin = installedPlugin(identity, options);
+  if (!plugin) throw new Error(`plugin not installed: ${id}`);
+  const pin = libraryEntryPin(identity, { ...options, scope: plugin.scope });
+  if (!options.force && pin && extensionContentDigest(plugin.rootPath) !== pin.sha256)
+    throw new Error(`plugin_local_changes: ${id}; use --force to replace local changes`);
+  const record = readPluginInstallRecord(identity.name, { ...options, scope: plugin.scope });
+  if (typeof record?.origin === "object" && record.origin.kind === "interop")
+    throw new Error("interop packages require a new reviewed adoption; remove the installed copy and adopt it again");
+  const catalogOrigin = record?.origin && typeof record.origin === "object" && record.origin.kind === "catalog";
+  const discovery = discoverLibrary(options);
+  const catalog = catalogOrigin ? discovery.entries.find(
+    (entry2) => entry2.kind === identity.kind && entry2.name === identity.name && entry2.origin !== "installed"
+  ) : void 0;
+  if (catalogOrigin && !catalog)
+    throw new Error(
+      `plugin catalog source unavailable: ${id}; restore its pinned catalog entry or explicitly install a new source`
+    );
+  const entry = catalog ?? (pin ? resolveLibraryPackage(pin.sourceUrl, options) : void 0);
+  if (!entry) throw new Error(`plugin has no update source: ${id}`);
+  if (entry.name !== identity.name || entry.kind !== identity.kind)
+    throw new Error(`package identity mismatch: expected ${id}, found ${libraryEntryRef(entry)}`);
+  const requirements = classifyLibraryRequirements(entry, discovery.entries, options);
+  if (requirements.inactive?.length)
+    throw new Error(
+      `library_requirement_inactive: ${requirements.inactive.map(libraryEntryRef).join(", ")}; enable or repair these plugins explicitly`
+    );
+  if (requirements.unsatisfied.length)
+    throw new Error(
+      `library_requirement_missing: ${requirements.unsatisfied.map(libraryEntryRef).join(", ")}; install required resources before updating`
+    );
+  const plan = planLibraryInstall(entry, { ...options, scope: plugin.scope, force: true });
+  if (!options.force) plan.expectedInstalledDigest = extensionContentDigest(plugin.rootPath);
+  return plan;
+}
+function removeLibraryEntry(entry, options = {}) {
+  const installed = installedPlugin(entry, options);
+  if (!installed) throw new Error(`package not installed: ${libraryEntryRef(entry)}`);
+  const result = removePlugin(entry.name, { ...options, scope: installed.scope });
+  if (result.diagnostics.some((item) => item.type === "error"))
+    throw new Error(
+      `${result.diagnostics.map((item) => item.message).join("; ")}${result.recovery ? `; recovery: ${JSON.stringify(result.recovery)}` : ""}`
+    );
+  return result.recovery ? { recovery: result.recovery } : {};
+}
+function pinLibraryEntry(entry, options = {}) {
+  const installed = libraryInstallPath(entry, options);
+  const pin = libraryEntryPin(entry, options);
+  if (!pin) throw new Error(`plugin is not installed with a verified pin: ${entry.name}`);
+  if (extensionContentDigest(installed) !== pin.sha256)
+    throw new Error(`plugin_local_changes: ${entry.name}; reinstall explicitly to accept changed content`);
+  return pin;
+}
+function libraryEntryDrift(entry, options = {}) {
+  const installed = libraryInstallPath(entry, options);
+  if (!existsSync2(installed)) return { status: "missing" };
+  const pin = libraryEntryPin(entry, options);
+  if (!pin) return { status: "unpinned" };
+  const observed = extensionContentDigest(installed);
+  return { status: observed === pin.sha256 ? "clean" : "changed", expected: pin.sha256, observed };
+}
+function confirmedRemote() {
+  const settings = readSettings().integrations.library;
+  if (!settings.remote || settings.remote !== settings.confirmedRemote) throw new Error("library_remote_unconfirmed");
+  return settings.remote;
+}
+function confirmLibraryRemote(url) {
+  const current = readSettings().integrations.library.remote;
+  if (current !== null && current !== url) throw new Error("library_remote_mismatch");
+  updateSettings((settings) => {
+    if (settings.integrations.library.remote === null) settings.integrations.library.remote = url;
+    settings.integrations.library.confirmedRemote = url;
+  });
+}
+async function syncLibrary(direction, runner = runCommandVector) {
+  const settings = readSettings().integrations.library;
+  if (!settings.sync) throw new Error("library_sync_disabled");
+  const remote = confirmedRemote();
+  const cwd = path3.dirname(catalogPath());
+  const remoteResult = await runner("git", ["remote", "get-url", "library"], { cwd, workspaceRoot: cwd });
+  if (remoteResult.exitCode !== 0 || remoteResult.stdout.trim() !== remote)
+    throw new Error("library_remote_unconfirmed");
+  if (direction === "sync") {
+    const fetched = await runner("git", ["fetch", "library"], { cwd, workspaceRoot: cwd });
+    if (fetched.exitCode !== 0) throw new Error(fetched.stderr.trim() || "library sync failed");
+    const advanced = await runner("git", ["merge", "--ff-only", "FETCH_HEAD"], { cwd, workspaceRoot: cwd });
+    if (advanced.exitCode !== 0) throw new Error(advanced.stderr.trim() || "library sync failed");
+    return;
+  }
+  const result = await runner("git", ["push", "library"], { cwd, workspaceRoot: cwd });
+  if (result.exitCode !== 0) throw new Error(result.stderr.trim() || `library ${direction} failed`);
+}
+
+// src/domains/resources/skills/marketplace.ts
+init_esm_shims();
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "node:fs";
+import path5 from "node:path";
+
+// src/domains/resources/skills/loader.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path4 from "node:path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_SKILL_BYTES = 1024 * 1024;
+var SKILL_ACTIVATION_BODY_CAP_BYTES = 50 * 1024;
+var CORE_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "disable-model-invocation",
+  "allowed-tools",
+  "disallowed-tools"
+]);
+var SKILL_PRECEDENCE = {
+  package: 10,
+  userCompat: 20,
+  user: 30,
+  projectCompat: 40,
+  project: 50,
+  cli: 60
+};
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function defaultPrecedenceForScope(scope) {
+  switch (scope) {
+    case "package":
+      return SKILL_PRECEDENCE.package;
+    case "user":
+      return SKILL_PRECEDENCE.user;
+    case "project":
+      return SKILL_PRECEDENCE.project;
+    case "cli":
+      return SKILL_PRECEDENCE.cli;
+  }
+}
+function projectCompatTrusted(explicit) {
+  return explicit === true;
+}
+function defaultSkillRoots(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const home = input.home ?? homedir2();
+  const configDir = input.configDir ?? clioConfigDirSafe();
+  const trustProject = projectCompatTrusted(input.trustProjectCompatRoots);
+  const roots = [];
+  for (const root of enabledPluginResourceRoots("skills", cwd)) {
+    roots.push({
+      path: root.path,
+      scope: "package",
+      source: "plugin",
+      rootPath: root.rootPath,
+      plugin: true,
+      containment: root.rootPath,
+      origin: root.source,
+      precedence: SKILL_PRECEDENCE.package,
+      trusted: root.trust !== "foreign" || trustProject
+    });
+  }
+  for (const kind of INTEROP_AGENT_KINDS) {
+    if (kind.userSkillRoot === void 0 || kind.skillSource === void 0) continue;
+    roots.push({
+      path: path4.join(home, kind.userSkillRoot),
+      scope: "user",
+      source: kind.skillSource,
+      origin: `${kind.skillSource}-user`,
+      precedence: SKILL_PRECEDENCE.userCompat,
+      trusted: true,
+      containment: home
+    });
+  }
+  if (configDir) {
+    roots.push({
+      path: path4.join(configDir, "skills"),
+      scope: "user",
+      source: "clio-coder",
+      origin: "config",
+      precedence: SKILL_PRECEDENCE.user,
+      trusted: true,
+      containment: home
+    });
+  }
+  for (const kind of INTEROP_AGENT_KINDS) {
+    if (kind.projectSkillRoot === void 0 || kind.skillSource === void 0) continue;
+    roots.push({
+      path: path4.join(cwd, kind.projectSkillRoot),
+      scope: "project",
+      source: kind.skillSource,
+      origin: `${kind.skillSource}-project`,
+      precedence: SKILL_PRECEDENCE.projectCompat,
+      trusted: trustProject,
+      containment: cwd
+    });
+  }
+  roots.push({
+    path: path4.join(cwd, ".clio-coder", "skills"),
+    scope: "project",
+    source: "clio-coder",
+    origin: "project",
+    precedence: SKILL_PRECEDENCE.project,
+    trusted: true,
+    containment: cwd
+  });
+  return roots;
+}
+function clioConfigDirSafe() {
+  try {
+    return clioConfigDir();
+  } catch {
+    return null;
+  }
+}
+function splitSkillFrontmatter(raw) {
+  const split = splitYamlFrontmatter(raw);
+  if (!split.ok && split.reason === "missing") {
+    throw new Error("skill file is missing YAML frontmatter");
+  }
+  if (!split.ok && split.reason === "missing closing delimiter") {
+    throw new Error("skill file is missing a closing YAML frontmatter delimiter");
+  }
+  if (!split.ok && split.reason === "must be a YAML object") {
+    throw new Error("skill frontmatter must be a YAML object");
+  }
+  if (!split.ok) throw new Error(`skill frontmatter is ${split.reason}`);
+  return split;
+}
+function booleanField(frontmatter, key) {
+  return frontmatter[key] === true;
+}
+function rawToolListField(frontmatter, key) {
+  const raw = frontmatter[key];
+  const entries = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.filter((entry) => typeof entry === "string") : null;
+  if (entries === null) return void 0;
+  const tools = entries.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return tools.length > 0 ? [...new Set(tools)] : void 0;
+}
+var TOOL_NAMES_BY_LOWERCASE = new Map(Object.values(ToolNames).map((name) => [name.toLowerCase(), name]));
+function resolveDeclaredTools(declared) {
+  const tools = [];
+  const unrecognized = [];
+  for (const entry of declared) {
+    const resolved = TOOL_NAMES_BY_LOWERCASE.get(entry.toLowerCase());
+    if (resolved === void 0) unrecognized.push(entry);
+    else if (!tools.includes(resolved)) tools.push(resolved);
+  }
+  return { tools, unrecognized };
+}
+function declaredToolSurface(frontmatter, key, filePath, diagnostics) {
+  const declared = rawToolListField(frontmatter, key);
+  if (declared === void 0) return void 0;
+  const { tools, unrecognized } = resolveDeclaredTools(declared);
+  if (unrecognized.length > 0) {
+    diagnostics.push({
+      type: "warning",
+      message: `${key} names ${unrecognized.length === 1 ? "a tool" : "tools"} Clio does not have: ${unrecognized.join(", ")}`,
+      path: filePath
+    });
+  }
+  if (tools.length === 0 && key === "allowed-tools") {
+    diagnostics.push({
+      type: "warning",
+      message: "allowed-tools names no tool Clio has, so it narrows nothing; declare Clio tool names to confine this skill",
+      path: filePath
+    });
+    return void 0;
+  }
+  return tools.length > 0 ? tools : void 0;
+}
+function validationSubject(filePath) {
+  return path4.basename(filePath) === "SKILL.md" ? path4.basename(path4.dirname(filePath)) : path4.basename(filePath, ".md");
+}
+function validateNameFormat(name) {
+  const errors = [];
+  if (name.length > MAX_NAME_LENGTH) errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)");
+  }
+  if (name.startsWith("-") || name.endsWith("-")) errors.push("name must not start or end with a hyphen");
+  if (name.includes("--")) errors.push("name must not contain consecutive hyphens");
+  return errors;
+}
+function validateDescription(description) {
+  if (!description) return ["description is required"];
+  if (description.length > MAX_DESCRIPTION_LENGTH) {
+    return [`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`];
+  }
+  return [];
+}
+function warnLegacySkillMetadata(filePath) {
+  warnLegacyNaming(`clio: skill metadata in ${filePath}`, "clio-coder: skill metadata");
+}
+function extractMetadata(frontmatter, filePath) {
+  const metadata = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (CORE_FRONTMATTER_KEYS.has(key)) continue;
+    if (key === "clio-coder") {
+      metadata.clioCoder = value;
+      continue;
+    }
+    if (key === "clio") {
+      warnLegacySkillMetadata(filePath);
+      if (!("clio-coder" in frontmatter)) metadata.clioCoder = value;
+      continue;
+    }
+    metadata[key] = value;
+  }
+  return metadata;
+}
+function extractProvenance(frontmatter, filePath) {
+  const canonicalRaw = frontmatter["clio-coder"];
+  const legacyRaw = frontmatter.clio;
+  if (legacyRaw !== void 0) warnLegacySkillMetadata(filePath);
+  const clioCoderRaw = canonicalRaw ?? legacyRaw;
+  const clioCoder = clioCoderRaw !== null && typeof clioCoderRaw === "object" && !Array.isArray(clioCoderRaw) ? clioCoderRaw : void 0;
+  const field = (...keys) => {
+    for (const key of keys) {
+      if (clioCoder) {
+        const nested = stringField(clioCoder, key);
+        if (nested !== null) return nested;
+      }
+    }
+    for (const key of keys) {
+      const flat = stringField(frontmatter, key);
+      if (flat !== null) return flat;
+    }
+    return null;
+  };
+  const installUrl = field("source-url", "sourceUrl", "install-url");
+  const registryId = field("registry-id", "registryId");
+  const registryUrl = field("registry-url", "registryUrl");
+  const installedAt = field("installed-at", "installedAt");
+  const updatedAt = field("updated-at", "updatedAt");
+  const installedHash = field("installed-hash", "installedHash");
+  const auditRaw = field("audit");
+  const audit = auditRaw === "pass" || auditRaw === "warn" || auditRaw === "fail" || auditRaw === "unknown" ? auditRaw : void 0;
+  const installedByRaw = field("installed-by", "installedBy");
+  const installedBy = installedByRaw === "worker" ? installedByRaw : void 0;
+  if (!installUrl && !registryId && !registryUrl && !installedAt && !updatedAt && !installedHash && !audit && !installedBy)
+    return void 0;
+  return {
+    ...installUrl ? { installUrl } : {},
+    ...registryId ? { registryId } : {},
+    ...registryUrl ? { registryUrl } : {},
+    ...installedAt ? { installedAt } : {},
+    ...updatedAt ? { updatedAt } : {},
+    ...installedHash ? { installedHash } : {},
+    ...audit ? { audit } : {},
+    ...installedBy ? { installedBy } : {}
+  };
+}
+function canonicalizePath(filePath) {
+  try {
+    return realpathSync2.native(filePath);
+  } catch {
+    return path4.resolve(filePath);
+  }
+}
+function pathIsInside(candidate, anchor) {
+  return candidate === anchor || candidate.startsWith(anchor + path4.sep);
+}
+function containmentAnchor(root) {
+  if (root.containment === void 0) return null;
+  const anchor = canonicalizePath(root.containment);
+  const rootReal = canonicalizePath(root.path);
+  return pathIsInside(rootReal, anchor) ? anchor : rootReal;
+}
+function escapesContainment(fullPath, anchor, diagnostics) {
+  if (anchor === null) return false;
+  const resolved = canonicalizePath(fullPath);
+  if (pathIsInside(resolved, anchor)) return false;
+  diagnostics.push({
+    type: "warning",
+    message: `skill path resolves to ${resolved}, outside ${anchor}; a skill root may not leave its scope through a symlink`,
+    path: fullPath
+  });
+  return true;
+}
+function loadSkillFile(filePath, root) {
+  const diagnostics = [];
+  let bytes;
+  try {
+    bytes = readFileSync3(filePath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      candidate: null,
+      diagnostics: [{ type: "warning", message: `skill file could not be read: ${reason}`, path: filePath }]
+    };
+  }
+  if (bytes.byteLength > MAX_SKILL_BYTES) {
+    return {
+      candidate: null,
+      diagnostics: [
+        {
+          type: "warning",
+          message: `skill file is ${bytes.byteLength} bytes, over the ${MAX_SKILL_BYTES}-byte limit for a SKILL.md`,
+          path: filePath
+        }
+      ]
+    };
+  }
+  const raw = bytes.toString("utf8");
+  if (bytes.includes(0) || !Buffer.from(raw, "utf8").equals(bytes)) {
+    return {
+      candidate: null,
+      diagnostics: [
+        {
+          type: "warning",
+          message: "skill file is not valid UTF-8 text; a SKILL.md is a document, not a binary payload",
+          path: filePath
+        }
+      ]
+    };
+  }
+  if (bytes.byteLength > SKILL_ACTIVATION_BODY_CAP_BYTES) {
+    diagnostics.push({
+      type: "warning",
+      message: `skill file is ${bytes.byteLength} bytes; activation delivers at most ${SKILL_ACTIVATION_BODY_CAP_BYTES}, so the model will not be shown the rest`,
+      path: filePath
+    });
+  }
+  let parsed;
+  try {
+    parsed = splitSkillFrontmatter(raw);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { candidate: null, diagnostics: [{ type: "warning", message: reason, path: filePath }] };
+  }
+  const pathSubject = validationSubject(filePath);
+  const frontmatterName = stringField(parsed.frontmatter, "name");
+  const rawName = frontmatterName ?? pathSubject;
+  const name = rawName === "clio-dev" ? "clio-coder-dev" : rawName === "clio-test" ? "clio-coder-test" : rawName;
+  if (name !== rawName) warnLegacyNaming(rawName, name);
+  const description = stringField(parsed.frontmatter, "description");
+  for (const message of validateDescription(description)) diagnostics.push({ type: "warning", message, path: filePath });
+  if (frontmatterName && frontmatterName !== pathSubject) {
+    diagnostics.push({
+      type: "warning",
+      message: `name "${frontmatterName}" differs from path subject "${pathSubject}"; using frontmatter name`,
+      path: filePath
+    });
+  }
+  for (const message of validateNameFormat(name)) diagnostics.push({ type: "warning", message, path: filePath });
+  if (!description) return { candidate: null, diagnostics };
+  const baseDir = path4.dirname(filePath);
+  const scope = root.scope;
+  const sourceInfo = {
+    path: filePath,
+    scope,
+    ...root.origin ? { source: root.origin } : {}
+  };
+  const provenance = extractProvenance(parsed.frontmatter, filePath);
+  const allowedTools = declaredToolSurface(parsed.frontmatter, "allowed-tools", filePath, diagnostics);
+  const disallowedTools = declaredToolSurface(parsed.frontmatter, "disallowed-tools", filePath, diagnostics);
+  let content;
+  try {
+    content = resolvePackageReferences(parsed.body.trim(), root);
+  } catch (error) {
+    diagnostics.push({ type: "warning", message: String(error), path: filePath });
+    return { candidate: null, diagnostics };
+  }
+  const skill = {
+    name,
+    description,
+    filePath,
+    baseDir,
+    content,
+    sourceInfo,
+    disableModelInvocation: booleanField(parsed.frontmatter, "disable-model-invocation"),
+    ...allowedTools ? { allowedTools } : {},
+    ...disallowedTools ? { disallowedTools } : {},
+    source: root.source ?? "clio-coder",
+    scope,
+    hash: sha256(raw),
+    normalizedHash: normalizedSkillHash(raw),
+    pathSubject,
+    trusted: root.trusted ?? true,
+    precedence: root.precedence ?? defaultPrecedenceForScope(scope),
+    metadata: extractMetadata(parsed.frontmatter, filePath),
+    diagnostics,
+    ...provenance ? { provenance } : {}
+  };
+  return { candidate: { skill, canonicalPath: canonicalizePath(filePath) }, diagnostics };
+}
+function isSkillMarkdownFile(entryName) {
+  return entryName === "SKILL.md" || entryName.endsWith(".md");
+}
+function collectSkills(root, dir, diagnostics, includeRootFiles, anchor = containmentAnchor(root)) {
+  if (!existsSync3(dir)) return [];
+  if (escapesContainment(dir, anchor, diagnostics)) return [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({ type: "warning", message: `skill root could not be read: ${reason}`, path: dir });
+    return [];
+  }
+  const skillEntry = entries.find((entry) => entry.name === "SKILL.md" && entry.isFile());
+  if (skillEntry) {
+    const skillPath = path4.join(dir, skillEntry.name);
+    if (escapesContainment(skillPath, anchor, diagnostics)) return [];
+    const loaded = loadSkillFile(skillPath, root);
+    diagnostics.push(...loaded.diagnostics);
+    return loaded.candidate ? [loaded.candidate] : [];
+  }
+  const candidates = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink() && existsSync3(path4.join(fullPath, "SKILL.md"))) {
+      candidates.push(...collectSkills(root, fullPath, diagnostics, false, anchor));
+      continue;
+    }
+    if (!includeRootFiles || !entry.isFile() && !entry.isSymbolicLink() || !isSkillMarkdownFile(entry.name)) continue;
+    if (escapesContainment(fullPath, anchor, diagnostics)) continue;
+    const loaded = loadSkillFile(fullPath, root);
+    diagnostics.push(...loaded.diagnostics);
+    if (loaded.candidate) candidates.push(loaded.candidate);
+  }
+  return candidates;
+}
+function loadSkillRoot(root, diagnostics) {
+  const entries = readRootEntries(root, "skill", diagnostics);
+  if (entries.length === 0) return [];
+  return collectSkills(root, root.path, diagnostics, true);
+}
+function explicitSkillRoot(filePath) {
+  return {
+    path: filePath,
+    scope: "cli",
+    source: "path",
+    origin: "explicit-path",
+    precedence: SKILL_PRECEDENCE.cli,
+    trusted: true
+  };
+}
+function loadExplicitSkillPath(inputPath, diagnostics, packageRoots, cwd) {
+  const resolved = path4.resolve(inputPath);
+  const identity = canonicalizePath(resolved);
+  const owner = packageRoots.find((candidate) => {
+    const relative = path4.relative(canonicalizePath(candidate.path), identity);
+    return relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
+  });
+  if (!owner && ["user", "project"].some((scope) => {
+    const relative = path4.relative(canonicalizePath(pluginBaseDir(scope, cwd)), identity);
+    return relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
+  })) {
+    diagnostics.push({
+      type: "warning",
+      message: "explicit skill belongs to an inactive or undeclared plugin resource",
+      path: resolved
+    });
+    return [];
+  }
+  const root = {
+    ...explicitSkillRoot(resolved),
+    ...owner ? {
+      ...owner.rootPath ? { rootPath: owner.rootPath, containment: owner.rootPath } : {},
+      ...owner.plugin !== void 0 ? { plugin: owner.plugin } : {},
+      trusted: owner.trusted
+    } : {}
+  };
+  if (!existsSync3(resolved)) {
+    diagnostics.push({ type: "warning", message: `explicit skill path does not exist: ${resolved}`, path: resolved });
+    return [];
+  }
+  const skillFile = path4.basename(resolved) === "SKILL.md" || resolved.endsWith(".md") ? resolved : path4.join(resolved, "SKILL.md");
+  if (!existsSync3(skillFile)) {
+    const packages = collectSkills(root, resolved, diagnostics, false);
+    if (packages.length > 0) return packages;
+    diagnostics.push({
+      type: "warning",
+      message: `explicit skill path is not a SKILL.md file, skill directory, or catalog of skill packages: ${resolved}`,
+      path: resolved
+    });
+    return [];
+  }
+  const loaded = loadSkillFile(skillFile, root);
+  diagnostics.push(...loaded.diagnostics);
+  return loaded.candidate ? [loaded.candidate] : [];
+}
+function compareSkillCandidates(a, b) {
+  const trust = Number(a.trusted) - Number(b.trusted);
+  if (trust !== 0) return trust;
+  const precedence = a.precedence - b.precedence;
+  if (precedence !== 0) return precedence;
+  const rank = interopSourceRank(b.source) - interopSourceRank(a.source);
+  if (rank !== 0) return rank;
+  return a.filePath.localeCompare(b.filePath);
+}
+function dedupeCanonicalSkillPaths(candidates, diagnostics) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const list = byPath.get(candidate.canonicalPath) ?? [];
+    list.push(candidate);
+    byPath.set(candidate.canonicalPath, list);
+  }
+  const winners = [];
+  for (const entries of byPath.values()) {
+    if (entries.length === 1) {
+      const only = entries[0];
+      if (only) winners.push(only);
+      continue;
+    }
+    const sorted = [...entries].sort((a, b) => compareSkillCandidates(a.skill, b.skill));
+    const winner = sorted[sorted.length - 1];
+    if (!winner) continue;
+    winners.push(winner);
+    for (const loser of sorted.slice(0, -1)) {
+      diagnostics.push({
+        type: "warning",
+        message: `${loser.skill.name} at ${loser.skill.filePath} resolves to the same canonical skill file as ${winner.skill.filePath}, which is the entry in use`,
+        path: loser.skill.filePath
+      });
+    }
+  }
+  return winners;
+}
+function resolveSkillCollisions(candidates) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = candidate.skill.name.trim();
+    if (key.length === 0) continue;
+    const list = byName.get(key) ?? [];
+    list.push(candidate);
+    byName.set(key, list);
+  }
+  const winners = [];
+  const diagnostics = [];
+  for (const [name, entries] of byName.entries()) {
+    const sorted = [...entries].sort((a, b) => compareSkillCandidates(a.skill, b.skill));
+    const winner = sorted[sorted.length - 1];
+    if (!winner) continue;
+    winners.push(winner.skill);
+    for (const loser of sorted.slice(0, -1)) {
+      diagnostics.push({
+        type: "collision",
+        message: `${name} from ${winner.skill.source}/${winner.skill.scope} overrides ${loser.skill.source}/${loser.skill.scope}`,
+        path: loser.skill.filePath,
+        collision: {
+          name,
+          winnerPath: winner.skill.filePath,
+          loserPath: loser.skill.filePath,
+          winnerScope: winner.skill.scope,
+          loserScope: loser.skill.scope
+        }
+      });
+    }
+  }
+  return { winners, diagnostics };
+}
+function requiresDiagnostics(winners) {
+  const names = new Set(winners.map((skill) => skill.name));
+  const out = [];
+  for (const skill of winners) {
+    const requires = skill.metadata.requires;
+    if (!Array.isArray(requires)) continue;
+    for (const entry of requires) {
+      if (typeof entry !== "string" || !entry.startsWith("skill:")) continue;
+      const dep = entry.slice("skill:".length).trim();
+      if (dep.length === 0 || names.has(dep)) continue;
+      out.push({
+        type: "warning",
+        message: `${skill.name} requires skill "${dep}" which is not available`,
+        path: skill.filePath
+      });
+    }
+  }
+  return out;
+}
+function loadSkills(input = {}) {
+  const roots = input.roots ?? (input.disableDiscovery === true ? [] : defaultSkillRoots(input));
+  const diagnostics = [];
+  const packageRoots = (input.explicitSkillPaths?.length ?? 0) > 0 ? defaultSkillRoots(input).filter((root) => root.scope === "package") : [];
+  const candidates = [
+    ...roots.flatMap((root) => loadSkillRoot(root, diagnostics)),
+    ...(input.explicitSkillPaths ?? []).flatMap(
+      (skillPath) => loadExplicitSkillPath(skillPath, diagnostics, packageRoots, input.cwd ?? process.cwd())
+    )
+  ];
+  const deduped = dedupeCanonicalSkillPaths(candidates, diagnostics);
+  const resolved = resolveSkillCollisions(deduped);
+  const winners = [...resolved.winners].sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    items: winners,
+    diagnostics: [...diagnostics, ...resolved.diagnostics, ...requiresDiagnostics(winners)]
+  };
+}
+function modelVisibleSkills(skills) {
+  return skills.filter((skill) => skill.trusted && !skill.disableModelInvocation);
+}
+function skillCatalogValidity(list) {
+  if (list.diagnostics.some((diag) => diag.type === "error")) return { ok: false, reason: "load-error" };
+  if (list.diagnostics.some((diag) => diag.type === "collision")) return { ok: false, reason: "collision" };
+  const loadedPaths = new Set(list.items.map((skill) => skill.filePath));
+  const unloadable = list.diagnostics.some(
+    (diag) => diag.type === "warning" && diag.path !== void 0 && !loadedPaths.has(diag.path)
+  );
+  if (unloadable) return { ok: false, reason: "unloadable-file" };
+  if (list.items.length === 0) return { ok: false, reason: "no-skills" };
+  return { ok: true, reason: null };
+}
+var SKILL_SURFACE_CLEAR_ARG = "off";
+function parseSkillCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/skill ")) return null;
+  const rest = trimmed.slice("/skill ".length).trim();
+  const separator = rest.search(/\s/);
+  const name = separator === -1 ? rest : rest.slice(0, separator);
+  if (name.length === 0) return null;
+  const args = separator === -1 ? "" : rest.slice(separator).trim();
+  return { name, args };
+}
+function expandSkillInvocationInput(input, skills, _options = {}) {
+  const command = parseSkillCommand(input);
+  if (!command) return { expanded: false, text: input, args: "", diagnostics: skills.diagnostics };
+  const skill = skills.items.find((entry) => entry.name === command.name);
+  const args = command.args;
+  if (!skill) return { expanded: false, text: input, args, diagnostics: skills.diagnostics };
+  return {
+    expanded: true,
+    text: args,
+    args,
+    skill,
+    triggeredBy: "slash-command",
+    diagnostics: skills.diagnostics
+  };
+}
+function parsePendingSkillRequests(input, skills, options = {}) {
+  const command = parseSkillCommand(input);
+  if (command) {
+    const name = command.name;
+    const args = command.args;
+    const installedSkill = skills.items.find((entry) => entry.name === name);
+    if (installedSkill) {
+      return {
+        text: args,
+        pendingSkillRequests: [
+          {
+            name,
+            args,
+            source: "slash-command",
+            installed: true,
+            filePath: installedSkill.filePath
+          }
+        ]
+      };
+    }
+    const marketplaceSkill = getMarketplaceSkills(options.cwd ? { cwd: options.cwd } : {}).find((s) => s.name === name);
+    if (marketplaceSkill) {
+      return {
+        text: args,
+        pendingSkillRequests: [
+          {
+            name,
+            args,
+            source: "marketplace",
+            installed: false,
+            marketplaceRef: marketplaceSkill.sourceUrl
+          }
+        ]
+      };
+    }
+    return {
+      text: args,
+      pendingSkillRequests: [
+        {
+          name,
+          args,
+          source: "slash-command",
+          installed: false
+        }
+      ]
+    };
+  }
+  return {
+    text: input,
+    pendingSkillRequests: []
+  };
+}
+
+// src/domains/resources/skills/marketplace.ts
+var MARKETPLACE_UNCONFIGURED = "no local skill marketplace catalog or index configured";
+function packageCatalogDir() {
+  try {
+    return path5.join(resolvePackageRoot(), "library", "skills");
+  } catch {
+    return null;
+  }
+}
+function packageIndexPath() {
+  try {
+    return path5.join(resolvePackageRoot(), "library", "skills", "skill-marketplace.json");
+  } catch {
+    return null;
+  }
+}
+function defaultIndexPath() {
+  try {
+    const configured = path5.join(clioConfigDir(), "skill-marketplace.json");
+    if (existsSync4(configured)) return configured;
+  } catch {
+  }
+  const bundled = packageIndexPath();
+  return bundled && existsSync4(bundled) ? bundled : null;
+}
+function isIndexSkill(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.name === "string" && record.name.trim().length > 0 && typeof record.description === "string" && typeof record.sourceUrl === "string" && record.sourceUrl.trim().length > 0;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function optionalTriggerList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const triggers = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return triggers.length > 0 ? triggers : void 0;
+}
+function indexAudit(value) {
+  return value === "pass" || value === "warn" || value === "fail" || value === "unknown" ? value : void 0;
+}
+function parseMarketplaceIndex(indexPath, diagnostics = []) {
+  try {
+    const parsed = JSON.parse(readFileSync4(indexPath, "utf8"));
+    const rawSkills = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.skills) ? parsed.skills : [];
+    return rawSkills.filter(isIndexSkill).flatMap((skill) => {
+      const record = skill;
+      const version = optionalString(record.version);
+      const audit = indexAudit(record.audit);
+      const category = optionalString(record.category);
+      const triggers = optionalTriggerList(record.triggers);
+      if (record.kind !== void 0 && !["skill", "agent", "prompt", "fleet"].includes(String(record.kind))) {
+        diagnostics.push(`skill marketplace index entry has unsupported kind: ${skill.name}`);
+        return [];
+      }
+      if (record.requires !== void 0 && (!Array.isArray(record.requires) || record.requires.some((entry) => typeof entry !== "string"))) {
+        diagnostics.push(`library_requirement_malformed: ${skill.name}`);
+        return [];
+      }
+      const kind = record.kind === "agent" || record.kind === "prompt" || record.kind === "fleet" ? record.kind : "skill";
+      const requires = Array.isArray(record.requires) ? record.requires.filter((entry) => typeof entry === "string") : void 0;
+      const overlay = optionalString(record.overlay);
+      if (overlay && (path5.isAbsolute(overlay) || overlay.split("/").includes(".."))) {
+        diagnostics.push(`skill marketplace index entry has an overlay outside the package: ${skill.name}`);
+        return [];
+      }
+      const exclude = optionalTriggerList(record.exclude);
+      return [
+        {
+          kind,
+          name: skill.name.trim(),
+          description: skill.description.trim(),
+          sourceUrl: skill.sourceUrl.trim(),
+          ...version ? { version } : {},
+          ...audit ? { audit } : {},
+          ...category ? { category } : {},
+          ...triggers ? { triggers } : {},
+          ...requires ? { requires } : {},
+          ...overlay ? { overlay } : {},
+          ...exclude ? { exclude } : {},
+          origin: "index"
+        }
+      ];
+    });
+  } catch (err) {
+    diagnostics.push(`skill marketplace index unreadable: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+}
+function looksLikeSkillCatalog(dir) {
+  if (!existsSync4(dir)) return false;
+  try {
+    return readdirSync2(dir, { withFileTypes: true }).some((entry) => {
+      if (!entry.isDirectory()) return false;
+      const child = path5.join(dir, entry.name);
+      if (existsSync4(path5.join(child, "SKILL.md"))) return true;
+      try {
+        return readdirSync2(child, { withFileTypes: true }).some(
+          (inner) => inner.isDirectory() && existsSync4(path5.join(child, inner.name, "SKILL.md"))
+        );
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+function resolveCatalogDir(options) {
+  if (options.catalogDir === null) return null;
+  if (options.catalogDir) return path5.resolve(options.catalogDir);
+  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
+  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv.trim());
+  const repoLibraryCatalog = path5.join(options.cwd ?? process.cwd(), "library", "skills");
+  if (looksLikeSkillCatalog(repoLibraryCatalog)) return repoLibraryCatalog;
+  const repoCatalog = path5.join(options.cwd ?? process.cwd(), "skills");
+  if (looksLikeSkillCatalog(repoCatalog)) return repoCatalog;
+  const bundled = packageCatalogDir();
+  return bundled && looksLikeSkillCatalog(bundled) ? bundled : null;
+}
+function catalogCategory(catalogDir, baseDir) {
+  const rel = path5.relative(catalogDir, baseDir);
+  const category = path5.dirname(rel);
+  if (rel.length === 0 || rel.startsWith("..") || category === "." || category.startsWith("..")) return void 0;
+  return category;
+}
+function catalogEntry(skill, catalogDir) {
+  const version = typeof skill.metadata.version === "string" ? skill.metadata.version : void 0;
+  const category = catalogCategory(catalogDir, skill.baseDir);
+  const triggers = optionalTriggerList(skill.metadata.triggers);
+  return {
+    name: skill.name,
+    description: skill.description,
+    sourceUrl: skill.baseDir,
+    ...version ? { version } : {},
+    ...skill.provenance?.audit ? { audit: skill.provenance.audit } : {},
+    ...category ? { category } : {},
+    ...triggers ? { triggers } : {},
+    origin: "catalog",
+    kind: "skill"
+  };
+}
+function catalogSkills(dir, diagnostics) {
+  const list = loadSkills({ disableDiscovery: true, explicitSkillPaths: [dir] });
+  for (const diag of list.diagnostics) {
+    if (diag.type === "warning" || diag.type === "error") diagnostics.push(diag.message);
+  }
+  return list.items.map((skill) => catalogEntry(skill, dir));
+}
+function discoverMarketplaceSkills(options = {}) {
+  if (options.indexPath === void 0 && options.catalogDir === void 0) {
+    const library = discoverLibrary(options.cwd ? { cwd: options.cwd } : {});
+    const skills2 = library.entries.filter((entry) => entry.kind === "skill" && entry.origin !== "installed").map((entry) => ({ ...entry, kind: "skill", origin: entry.origin === "index" ? "index" : "catalog" }));
+    return { status: skills2.length ? "installable" : "unavailable", skills: skills2, diagnostics: library.diagnostics };
+  }
+  const diagnostics = [];
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const indexPath = options.indexPath === null ? null : options.indexPath ?? process.env.CLIO_CODER_SKILL_MARKETPLACE_INDEX ?? null;
+  const resolvedIndexPath = indexPath ?? defaultIndexPath();
+  const indexSkills = options.indexPath !== null && resolvedIndexPath && existsSync4(resolvedIndexPath) ? parseMarketplaceIndex(resolvedIndexPath, diagnostics) : [];
+  const overlayNames = new Set(indexSkills.filter((skill) => skill.overlay).map((skill) => skill.name));
+  const catalogDir = resolveCatalogDir(options);
+  if (catalogDir) {
+    for (const skill of catalogSkills(catalogDir, diagnostics)) {
+      if (seen.has(skill.name) || overlayNames.has(skill.name)) continue;
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  for (const skill of indexSkills) {
+    if (seen.has(skill.name)) continue;
+    seen.add(skill.name);
+    skills.push(skill);
+  }
+  if (skills.length === 0 && diagnostics.length === 0) {
+    diagnostics.push(MARKETPLACE_UNCONFIGURED);
+  }
+  return { status: skills.length > 0 ? "installable" : "unavailable", skills, diagnostics };
+}
+function getMarketplaceSkills(options = {}) {
+  return discoverMarketplaceSkills(options).skills;
+}
+function marketplaceInstallShaping(skill) {
+  const shaping = {};
+  if (skill.overlay) shaping.overlay = path5.join(resolvePackageRoot(), skill.overlay);
+  if (skill.exclude && skill.exclude.length > 0) shaping.exclude = [...skill.exclude];
+  return shaping;
+}
+function resolveMarketplaceShaping(options = {}) {
+  return (installed) => {
+    const entry = getMarketplaceSkills(options).find(
+      (skill) => skill.name === installed.name && skill.sourceUrl === installed.sourceUrl
+    );
+    if (!entry || !entry.overlay && !entry.exclude) return void 0;
+    return marketplaceInstallShaping(entry);
+  };
+}
+function installSkill(input) {
+  const requested = input.source.trim();
+  const source = requested === "clio-dev" ? "clio-coder-dev" : requested === "clio-test" ? "clio-coder-test" : requested;
+  if (source !== requested) warnLegacyNaming(requested, source);
+  if (input.overlay || input.exclude?.length || input.configDir)
+    throw new Error("package installs use the prepared manifest tree and the active Clio profile");
+  const entry = resolveLibraryPackage(source, input.cwd ? { cwd: input.cwd } : {});
+  if (entry.kind !== "skill") throw new Error(`expected a skill package, found ${entry.kind}:${entry.name}`);
+  if (input.name && input.name !== entry.name) throw new Error("package identities cannot be renamed at install");
+  const plan = planLibraryInstall(entry, {
+    ...input.cwd ? { cwd: input.cwd } : {},
+    scope: input.scope ?? "user",
+    force: input.force ?? false
+  });
+  installLibraryPlan(plan);
+  const candidate = readPluginManifest(plan.path);
+  const component = candidate.manifest?.clio.components.find((item) => item.kind === "skill");
+  if (!component) throw new Error("installed skill package has no skill component");
+  return {
+    name: entry.name,
+    scope: input.scope ?? "user",
+    path: pluginResourcePath(plan.path, component.path),
+    sourceUrl: entry.sourceUrl,
+    installedHash: plan.sha256,
+    warnings: []
+  };
+}
+
+export {
+  recipeIdFromPath,
+  parseAgentRecipeSchema,
+  parsePluginGithubSource,
+  pluginLocalPath,
+  fetchPluginSource,
+  bundledLibraryIndexPath,
+  libraryEntryRef,
+  discoverLibrary,
+  resolveLibraryRequirements,
+  resolveInstalledLibraryEntry,
+  registerLibraryPackage,
+  libraryWorkspace,
+  libraryInstallPath,
+  libraryEntryInstalled,
+  libraryEntryPin,
+  classifyLibraryRequirements,
+  planLibraryInstall,
+  releaseLibraryPlan,
+  commitLibraryInstallPlan,
+  installLibraryPlan,
+  resolveLibraryPackage,
+  planLibraryUpdate,
+  removeLibraryEntry,
+  pinLibraryEntry,
+  libraryEntryDrift,
+  confirmLibraryRemote,
+  syncLibrary,
+  MARKETPLACE_UNCONFIGURED,
+  discoverMarketplaceSkills,
+  getMarketplaceSkills,
+  marketplaceInstallShaping,
+  resolveMarketplaceShaping,
+  installSkill,
+  projectCompatTrusted,
+  defaultSkillRoots,
+  loadSkills,
+  modelVisibleSkills,
+  skillCatalogValidity,
+  SKILL_SURFACE_CLEAR_ARG,
+  parseSkillCommand,
+  expandSkillInvocationInput,
+  parsePendingSkillRequests
+};
+//# sourceMappingURL=chunk-EXKUF426.js.map