@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-7FBCRWVT.js

@@ -1,1801 +0,0 @@
-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-I47EJPYL.js";
-import {
-  extensionContentDigest,
-  isSemanticVersion
-} from "./chunk-XW2UZICE.js";
-import {
-  readSettings,
-  updateSettings
-} from "./chunk-FPS4R2RN.js";
-import {
-  warnLegacyNaming
-} from "./chunk-DVNAPPXU.js";
-import {
-  INTEROP_AGENT_KINDS,
-  interopSourceRank
-} from "./chunk-5EQO5NWP.js";
-import {
-  ToolNames
-} from "./chunk-V4XJWDHR.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  buildSafeToolEnv,
-  runCommandVector
-} from "./chunk-XTQ7MEJG.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/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 path 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 path.resolve(cwd, source.startsWith("~/") ? path.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(path.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 = path.join(temp, remote.subdir);
-    if (!existsSync(root) || !statSync(root).isDirectory())
-      throw new Error(`plugin source has no directory ${remote.subdir || "."}: ${source}`);
-    const relative = path.relative(realpathSync(temp), realpathSync(root));
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
-      throw new Error("plugin source escapes repository");
-    if (!remote.subdir) rmSync(path.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 : path.resolve(path.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: path.resolve(file)
-        }
-      ];
-    });
-  } catch (error) {
-    diagnostics.push(`library index unreadable: ${error instanceof Error ? error.message : String(error)}`);
-    return [];
-  }
-}
-function bundledLibraryIndexPath() {
-  return path.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 path2 from "node:path";
-function catalogPath() {
-  const configured = readSettings().integrations.library.catalog;
-  return path2.resolve(configured ?? path2.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(path2.resolve(options.catalog), diagnostics) : [];
-  const privateEntries = parseCatalog(privatePath, diagnostics);
-  const byRef = /* @__PURE__ */ new Map();
-  for (const entry of [
-    ...bundledPlugins,
-    ...privateEntries,
-    ...parseCatalog(path2.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" ? path2.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 ?? path2.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: path2.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 = path2.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 path4 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 path3 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: path3.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: path3.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: path3.join(cwd, kind.projectSkillRoot),
-      scope: "project",
-      source: kind.skillSource,
-      origin: `${kind.skillSource}-project`,
-      precedence: SKILL_PRECEDENCE.projectCompat,
-      trusted: trustProject,
-      containment: cwd
-    });
-  }
-  roots.push({
-    path: path3.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 path3.basename(filePath) === "SKILL.md" ? path3.basename(path3.dirname(filePath)) : path3.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 path3.resolve(filePath);
-  }
-}
-function pathIsInside(candidate, anchor) {
-  return candidate === anchor || candidate.startsWith(anchor + path3.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 = path3.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 = path3.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 = path3.join(dir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink() && existsSync3(path3.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 = path3.resolve(inputPath);
-  const identity = canonicalizePath(resolved);
-  const owner = packageRoots.find((candidate) => {
-    const relative = path3.relative(canonicalizePath(candidate.path), identity);
-    return relative !== ".." && !relative.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relative);
-  });
-  if (!owner && ["user", "project"].some((scope) => {
-    const relative = path3.relative(canonicalizePath(pluginBaseDir(scope, cwd)), identity);
-    return relative !== ".." && !relative.startsWith(`..${path3.sep}`) && !path3.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 = path3.basename(resolved) === "SKILL.md" || resolved.endsWith(".md") ? resolved : path3.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 path4.join(resolvePackageRoot(), "library", "skills");
-  } catch {
-    return null;
-  }
-}
-function packageIndexPath() {
-  try {
-    return path4.join(resolvePackageRoot(), "library", "skills", "skill-marketplace.json");
-  } catch {
-    return null;
-  }
-}
-function defaultIndexPath() {
-  try {
-    const configured = path4.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 && (path4.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 = path4.join(dir, entry.name);
-      if (existsSync4(path4.join(child, "SKILL.md"))) return true;
-      try {
-        return readdirSync2(child, { withFileTypes: true }).some(
-          (inner) => inner.isDirectory() && existsSync4(path4.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 path4.resolve(options.catalogDir);
-  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
-  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv.trim());
-  const repoLibraryCatalog = path4.join(options.cwd ?? process.cwd(), "library", "skills");
-  if (looksLikeSkillCatalog(repoLibraryCatalog)) return repoLibraryCatalog;
-  const repoCatalog = path4.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 = path4.relative(catalogDir, baseDir);
-  const category = path4.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 = path4.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: []
-  };
-}
-
-// src/domains/agents/recipe.ts
-init_esm_shims();
-import path5 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 = path5.resolve(rootDir);
-  const resolvedPath = path5.resolve(absPath);
-  const relPath = path5.relative(resolvedRoot, resolvedPath);
-  if (relPath === "" || relPath.startsWith("..") || path5.isAbsolute(relPath)) {
-    throw new Error(`recipe: path must live under rootDir (${resolvedPath} not under ${resolvedRoot})`);
-  }
-  if (path5.dirname(relPath) !== ".") {
-    throw new Error(`recipe: recipes must live directly under rootDir (${resolvedPath})`);
-  }
-  if (path5.extname(relPath) !== ".md") {
-    throw new Error(`recipe: recipe files must end in .md (${resolvedPath})`);
-  }
-  const id = path5.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
-  };
-}
-
-export {
-  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,
-  recipeIdFromPath,
-  parseAgentRecipeSchema
-};
-//# sourceMappingURL=chunk-7FBCRWVT.js.map