@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-536HXRFE.js

@@ -1,1257 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  frontmatterRegion,
-  normalizedSkillHash,
-  stripProvenanceLines
-} from "./chunk-DNCE23JJ.js";
-import {
-  readRootEntries,
-  splitYamlFrontmatter,
-  stringField
-} from "./chunk-U7H5WRG5.js";
-import {
-  enabledExtensionResourceRoots
-} from "./chunk-22PQ4TX4.js";
-import {
-  warnLegacyNaming
-} from "./chunk-DVNAPPXU.js";
-import {
-  INTEROP_AGENT_KINDS,
-  interopSourceRank
-} from "./chunk-5CY4Q6QI.js";
-import {
-  ToolNames
-} from "./chunk-EHOSNVVM.js";
-import {
-  resolvePackageRoot
-} from "./chunk-E3LEPLQ2.js";
-import {
-  fsyncDirectory
-} from "./chunk-ZZFWWYLX.js";
-import {
-  clioConfigDir
-} from "./chunk-CTTI7G3T.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/resources/skills/install.ts
-init_esm_shims();
-import { execFileSync } from "node:child_process";
-import {
-  cpSync,
-  existsSync as existsSync3,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync as readFileSync3,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { homedir as homedir2, tmpdir } from "node:os";
-import path3 from "node:path";
-
-// src/domains/resources/skills/loader.ts
-init_esm_shims();
-import { createHash } from "node:crypto";
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import path2 from "node:path";
-
-// src/domains/resources/skills/marketplace.ts
-init_esm_shims();
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import path from "node:path";
-var MARKETPLACE_UNCONFIGURED = "no local skill marketplace catalog or index configured";
-function packageCatalogDir() {
-  try {
-    return path.join(resolvePackageRoot(), "skills");
-  } catch {
-    return null;
-  }
-}
-function packageIndexPath() {
-  try {
-    return path.join(resolvePackageRoot(), "skills", "skill-marketplace.json");
-  } catch {
-    return null;
-  }
-}
-function defaultIndexPath() {
-  try {
-    const configured = path.join(clioConfigDir(), "skill-marketplace.json");
-    if (existsSync(configured)) return configured;
-  } catch {
-  }
-  const bundled = packageIndexPath();
-  return bundled && existsSync(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(readFileSync(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 && (path.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 (!existsSync(dir)) return false;
-  try {
-    return readdirSync(dir, { withFileTypes: true }).some((entry) => {
-      if (!entry.isDirectory()) return false;
-      const child = path.join(dir, entry.name);
-      if (existsSync(path.join(child, "SKILL.md"))) return true;
-      try {
-        return readdirSync(child, { withFileTypes: true }).some(
-          (inner) => inner.isDirectory() && existsSync(path.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 path.resolve(options.catalogDir);
-  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
-  if (fromEnv && fromEnv.trim().length > 0) return path.resolve(fromEnv.trim());
-  const repoCatalog = path.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 = path.relative(catalogDir, baseDir);
-  const category = path.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 = {}) {
-  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 && existsSync(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 = path.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);
-  const spec = parseSkillSourceSpec(source);
-  if (spec?.kind === "local" && isSkillName(source) && !existsSync(spec.path)) {
-    const skill = getMarketplaceSkills({ ...input.cwd ? { cwd: input.cwd } : {} }).find(
-      (entry) => entry.name === source
-    );
-    if (!skill) {
-      throw new Error(`"${source}" is neither an existing local path nor available in the local marketplace`);
-    }
-    return installSkillFromSource({ ...input, ...marketplaceInstallShaping(skill), source: skill.sourceUrl });
-  }
-  return installSkillFromSource({ ...input, source });
-}
-
-// src/domains/resources/skills/loader.ts
-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 = {
-  extension: 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.extension;
-    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 ?? homedir();
-  const configDir = input.configDir ?? clioConfigDirSafe();
-  const trustProject = projectCompatTrusted(input.trustProjectCompatRoots);
-  const roots = [];
-  for (const root of enabledExtensionResourceRoots("skills", cwd)) {
-    roots.push({
-      path: root.path,
-      scope: "package",
-      source: "extension",
-      origin: root.source,
-      precedence: SKILL_PRECEDENCE.extension,
-      trusted: true
-    });
-  }
-  for (const kind of INTEROP_AGENT_KINDS) {
-    if (kind.userSkillRoot === void 0 || kind.skillSource === void 0) continue;
-    roots.push({
-      path: path2.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: path2.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: path2.join(cwd, kind.projectSkillRoot),
-      scope: "project",
-      source: kind.skillSource,
-      origin: `${kind.skillSource}-project`,
-      precedence: SKILL_PRECEDENCE.projectCompat,
-      trusted: trustProject,
-      containment: cwd
-    });
-  }
-  roots.push({
-    path: path2.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 path2.basename(filePath) === "SKILL.md" ? path2.basename(path2.dirname(filePath)) : path2.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 realpathSync.native(filePath);
-  } catch {
-    return path2.resolve(filePath);
-  }
-}
-function pathIsInside(candidate, anchor) {
-  return candidate === anchor || candidate.startsWith(anchor + path2.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 = readFileSync2(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 = path2.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);
-  const skill = {
-    name,
-    description,
-    filePath,
-    baseDir,
-    content: parsed.body.trim(),
-    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 (!existsSync2(dir)) return [];
-  if (escapesContainment(dir, anchor, diagnostics)) return [];
-  let entries;
-  try {
-    entries = readdirSync2(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 = path2.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 = path2.join(dir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink() && existsSync2(path2.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) {
-  const resolved = path2.resolve(inputPath);
-  const root = explicitSkillRoot(resolved);
-  if (!existsSync2(resolved)) {
-    diagnostics.push({ type: "warning", message: `explicit skill path does not exist: ${resolved}`, path: resolved });
-    return [];
-  }
-  const skillFile = path2.basename(resolved) === "SKILL.md" || resolved.endsWith(".md") ? resolved : path2.join(resolved, "SKILL.md");
-  if (!existsSync2(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 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 candidates = [
-    ...roots.flatMap((root) => loadSkillRoot(root, diagnostics)),
-    ...(input.explicitSkillPaths ?? []).flatMap((skillPath) => loadExplicitSkillPath(skillPath, diagnostics))
-  ];
-  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/install.ts
-var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var CLONE_TIMEOUT_MS = 6e4;
-function isSkillName(value) {
-  return value.length > 0 && value.length <= 64 && SKILL_NAME_PATTERN.test(value);
-}
-function repoRelativePath(filePath) {
-  if (path3.isAbsolute(filePath) || filePath.includes("\0")) return null;
-  const segments = filePath.split("/");
-  if (segments.some((segment) => segment === "..")) return null;
-  const normalized = path3.posix.normalize(filePath);
-  if (normalized.startsWith("..") || path3.posix.isAbsolute(normalized)) return null;
-  return normalized;
-}
-function parseSkillSourceSpec(source) {
-  const trimmed = source.trim();
-  if (trimmed.length === 0) return null;
-  const browser = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(?:blob|tree)\/([^/]+)\/(.+?)\/?$/);
-  if (browser?.[1] && browser[2] && browser[3] && browser[4]) {
-    const filePath = repoRelativePath(browser[4]);
-    if (!filePath) return null;
-    return {
-      kind: "github",
-      cloneUrl: `https://github.com/${browser[1]}/${browser[2]}.git`,
-      branch: browser[3],
-      filePath,
-      original: trimmed
-    };
-  }
-  const raw = trimmed.match(/^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+?)\/?$/);
-  if (raw?.[1] && raw[2] && raw[3] && raw[4]) {
-    const filePath = repoRelativePath(raw[4]);
-    if (!filePath) return null;
-    return {
-      kind: "github",
-      cloneUrl: `https://github.com/${raw[1]}/${raw[2]}.git`,
-      branch: raw[3],
-      filePath,
-      original: trimmed
-    };
-  }
-  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return null;
-  const expanded = trimmed.startsWith("~/") ? path3.join(homedir2(), trimmed.slice(2)) : trimmed;
-  return { kind: "local", path: path3.resolve(expanded), original: trimmed };
-}
-function installingAsWorker() {
-  return process.env.CLIO_CODER_WORKER_RUN === "1";
-}
-function yamlQuote(value) {
-  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-function canonicalizeProductMetadataBlock(lines) {
-  const hasCanonical = lines.some((line) => /^clio-coder:/.test(line));
-  const canonical = [];
-  let dropLegacyChildren = false;
-  for (const line of lines) {
-    if (/^clio:/.test(line)) {
-      dropLegacyChildren = hasCanonical;
-      if (!hasCanonical) canonical.push(line.replace(/^clio:/, "clio-coder:"));
-      continue;
-    }
-    if (dropLegacyChildren) {
-      if (line.trim().length === 0 || /^[ \t]/.test(line)) continue;
-      dropLegacyChildren = false;
-    }
-    canonical.push(line);
-  }
-  return canonical;
-}
-function injectProvenanceFrontmatter(rawText, fields) {
-  const region = frontmatterRegion(rawText);
-  if (!region) throw new Error("skill file is missing YAML frontmatter");
-  const kept = stripProvenanceLines(region.lines);
-  const stamps = [
-    `source-url: ${yamlQuote(fields.sourceUrl)}`,
-    `installed-at: ${yamlQuote(fields.installedAt)}`,
-    ...fields.updatedAt ? [`updated-at: ${yamlQuote(fields.updatedAt)}`] : [],
-    `installed-hash: ${yamlQuote(fields.installedHash)}`,
-    // Audit is a human decision; installs always land unreviewed.
-    "audit: unknown",
-    ...fields.installedBy ? [`installed-by: ${yamlQuote(fields.installedBy)}`] : []
-  ];
-  const canonicalKept = canonicalizeProductMetadataBlock(kept);
-  const clioIndex = canonicalKept.findIndex((line) => /^clio-coder:/.test(line));
-  if (clioIndex >= 0 && !/^clio-coder:\s*$/.test(canonicalKept[clioIndex])) {
-    return `${region.head}${[...canonicalKept, ...stamps].join("\n")}${region.tail}`;
-  }
-  const nested = stamps.map((line) => `  ${line}`);
-  if (clioIndex < 0) {
-    return `${region.head}${[...canonicalKept, "clio-coder:", ...nested].join("\n")}${region.tail}`;
-  }
-  let blockEnd = clioIndex + 1;
-  while (blockEnd < canonicalKept.length) {
-    const line = canonicalKept[blockEnd];
-    if (line.trim().length > 0 && !/^[ \t]/.test(line)) break;
-    blockEnd += 1;
-  }
-  return `${region.head}${[...canonicalKept.slice(0, blockEnd), ...nested, ...canonicalKept.slice(blockEnd)].join(
-    "\n"
-  )}${region.tail}`;
-}
-function resolveSkillDir(target) {
-  if (!existsSync3(target)) throw new Error(`skill source path does not exist: ${target}`);
-  const stat = statSync(target);
-  if (stat.isFile()) {
-    if (!target.endsWith(".md")) throw new Error(`skill source must be a SKILL.md file or directory: ${target}`);
-    return path3.dirname(target);
-  }
-  if (!existsSync3(path3.join(target, "SKILL.md"))) {
-    throw new Error(`skill source directory has no SKILL.md: ${target}`);
-  }
-  return target;
-}
-function fetchSource(spec) {
-  if (spec.kind === "local") {
-    return { skillDir: resolveSkillDir(spec.path), cleanup: () => {
-    } };
-  }
-  const tmp = mkdtempSync(path3.join(tmpdir(), "clio-coder-skill-"));
-  const cleanup = () => rmSync(tmp, { recursive: true, force: true });
-  try {
-    execFileSync("git", ["clone", "--depth", "1", "--branch", spec.branch, spec.cloneUrl, tmp], {
-      stdio: "pipe",
-      timeout: CLONE_TIMEOUT_MS
-    });
-    const target = path3.join(tmp, spec.filePath);
-    if (!existsSync3(target)) {
-      throw new Error(
-        `${spec.cloneUrl} (branch ${spec.branch}) has no ${spec.filePath}; the source-url may name a path that branch does not carry`
-      );
-    }
-    return { skillDir: resolveSkillDir(target), cleanup };
-  } catch (err) {
-    cleanup();
-    throw err instanceof Error ? err : new Error(String(err));
-  }
-}
-function copySkillDir(from, to, exclude = []) {
-  mkdirSync(path3.dirname(to), { recursive: true });
-  const excluded = new Set(exclude);
-  cpSync(from, to, {
-    recursive: true,
-    filter: (source) => {
-      const base = path3.basename(source);
-      if (base === ".git" || base === "node_modules") return false;
-      return !(excluded.size > 0 && path3.dirname(source) === from && excluded.has(base));
-    }
-  });
-}
-function shapeSource(fetched, shaping) {
-  const exclude = shaping.exclude ?? [];
-  if (!shaping.overlay && exclude.length === 0) return fetched;
-  if (shaping.overlay && !existsSync3(shaping.overlay)) {
-    fetched.cleanup();
-    throw new Error(`skill overlay directory does not exist: ${shaping.overlay}`);
-  }
-  const tmp = mkdtempSync(path3.join(tmpdir(), "clio-coder-skill-shape-"));
-  const shaped = path3.join(tmp, "skill");
-  const cleanup = () => {
-    rmSync(tmp, { recursive: true, force: true });
-    fetched.cleanup();
-  };
-  try {
-    copySkillDir(fetched.skillDir, shaped, exclude);
-    if (shaping.overlay) copySkillDir(shaping.overlay, shaped);
-    return { skillDir: resolveSkillDir(shaped), cleanup };
-  } catch (err) {
-    cleanup();
-    throw err instanceof Error ? err : new Error(String(err));
-  }
-}
-var skillSwapSequence = 0;
-function swapSkillDir(stage, dest) {
-  const suffix = `${process.pid}-${++skillSwapSequence}`;
-  const staging = `${dest}.clio-coder-staging-${suffix}`;
-  const backup = `${dest}.clio-coder-backup-${suffix}`;
-  rmSync(staging, { recursive: true, force: true });
-  try {
-    stage(staging);
-  } catch (err) {
-    rmSync(staging, { recursive: true, force: true });
-    throw err;
-  }
-  const hadPrevious = existsSync3(dest);
-  if (hadPrevious) renameSync(dest, backup);
-  try {
-    renameSync(staging, dest);
-  } catch (err) {
-    if (hadPrevious) renameSync(backup, dest);
-    rmSync(staging, { recursive: true, force: true });
-    throw err;
-  }
-  if (hadPrevious) rmSync(backup, { recursive: true, force: true });
-  fsyncDirectory(path3.dirname(dest));
-}
-function destinationRoot(scope, cwd, configDir) {
-  return scope === "user" ? path3.join(configDir ?? clioConfigDir(), "skills") : path3.join(cwd, ".clio-coder", "skills");
-}
-function validateSourceSkill(skillDir) {
-  const list = loadSkills({ disableDiscovery: true, explicitSkillPaths: [skillDir] });
-  const errors = list.diagnostics.filter((diag) => diag.type === "error");
-  if (errors.length > 0) {
-    throw new Error(`skill source failed validation: ${errors.map((diag) => diag.message).join("; ")}`);
-  }
-  const skill = list.items[0];
-  if (!skill || list.items.length !== 1) {
-    throw new Error(`skill source did not resolve to exactly one skill: ${skillDir}`);
-  }
-  return { skill, warnings: list.diagnostics.map((diag) => diag.message) };
-}
-function installSkillFromSource(input) {
-  const spec = parseSkillSourceSpec(input.source);
-  if (!spec) throw new Error(`unsupported skill source: ${input.source}`);
-  const cwd = input.cwd ?? process.cwd();
-  const scope = input.scope ?? "project";
-  const fetched = shapeSource(fetchSource(spec), input);
-  try {
-    const { skill, warnings } = validateSourceSkill(fetched.skillDir);
-    const name = (input.name ?? skill.name).trim();
-    if (!isSkillName(name)) {
-      throw new Error(`invalid skill name "${name}": use lowercase letters, numbers, and single hyphens`);
-    }
-    const dest = path3.join(destinationRoot(scope, cwd, input.configDir), name);
-    if (existsSync3(dest) && input.force !== true) {
-      throw new Error(`skill already installed at ${dest} (use --force to overwrite)`);
-    }
-    const sourceRaw = readFileSync3(skill.filePath, "utf8");
-    const installedHash = normalizedSkillHash(sourceRaw);
-    const destFile = path3.join(dest, "SKILL.md");
-    swapSkillDir((staging) => {
-      copySkillDir(fetched.skillDir, staging);
-      writeFileSync(
-        path3.join(staging, "SKILL.md"),
-        injectProvenanceFrontmatter(sourceRaw, {
-          sourceUrl: spec.original,
-          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          installedHash,
-          ...installingAsWorker() ? { installedBy: "worker" } : {}
-        }),
-        "utf8"
-      );
-    }, dest);
-    const after = loadSkills({ cwd, ...scope === "user" && input.configDir ? { configDir: input.configDir } : {} });
-    const installWarnings = after.diagnostics.filter((diag) => diag.path && path3.resolve(diag.path).startsWith(dest)).map((diag) => diag.message);
-    return {
-      name,
-      scope,
-      path: destFile,
-      sourceUrl: spec.original,
-      installedHash,
-      warnings: [...warnings, ...installWarnings]
-    };
-  } finally {
-    fetched.cleanup();
-  }
-}
-function managedSkills(cwd, configDir) {
-  const list = loadSkills({ cwd, ...configDir ? { configDir } : {} });
-  return list.items.filter(
-    (skill) => skill.source === "clio-coder" && (skill.scope === "user" || skill.scope === "project")
-  );
-}
-function updateOne(skill, force, shaping = {}) {
-  const sourceUrl = skill.provenance?.installUrl;
-  if (!sourceUrl) return { name: skill.name, status: "no-source", detail: "no source-url provenance recorded" };
-  const spec = parseSkillSourceSpec(sourceUrl);
-  if (!spec) return { name: skill.name, status: "error", detail: `unsupported source-url: ${sourceUrl}` };
-  let fetched;
-  try {
-    fetched = shapeSource(fetchSource(spec), shaping);
-  } catch (err) {
-    return { name: skill.name, status: "error", detail: err instanceof Error ? err.message : String(err) };
-  }
-  try {
-    validateSourceSkill(fetched.skillDir);
-    const remoteFile = path3.join(fetched.skillDir, "SKILL.md");
-    const remoteRaw = readFileSync3(remoteFile, "utf8");
-    const remoteHash = normalizedSkillHash(remoteRaw);
-    const localRaw = readFileSync3(skill.filePath, "utf8");
-    const localHash = normalizedSkillHash(localRaw);
-    const recordedHash = skill.provenance?.installedHash ?? null;
-    if (remoteHash === localHash) return { name: skill.name, status: "up-to-date" };
-    const locallyModified = recordedHash === null || localHash !== recordedHash;
-    if (locallyModified && !force) {
-      return { name: skill.name, status: "local-changes", detail: "skipped, use --force to overwrite" };
-    }
-    swapSkillDir((staging) => {
-      copySkillDir(fetched.skillDir, staging);
-      writeFileSync(
-        path3.join(staging, "SKILL.md"),
-        injectProvenanceFrontmatter(remoteRaw, {
-          sourceUrl,
-          installedAt: skill.provenance?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          installedHash: remoteHash,
-          // Who installed a skill is set once; an update, worker- or
-          // operator-run, does not change who put it there originally.
-          ...skill.provenance?.installedBy ? { installedBy: skill.provenance.installedBy } : {}
-        }),
-        "utf8"
-      );
-    }, skill.baseDir);
-    return { name: skill.name, status: "updated" };
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return { name: skill.name, status: "error", detail: reason };
-  } finally {
-    fetched.cleanup();
-  }
-}
-function updateSkills(input = {}) {
-  const cwd = input.cwd ?? process.cwd();
-  const skills = managedSkills(cwd, input.configDir);
-  const shapingFor = (skill) => skill.provenance?.installUrl && input.resolveShaping?.({ name: skill.name, sourceUrl: skill.provenance.installUrl }) || {};
-  if (input.name) {
-    const skill = skills.find((entry) => entry.name === input.name);
-    if (!skill) return [{ name: input.name, status: "error", detail: "not found in Clio-managed skill roots" }];
-    return [updateOne(skill, input.force === true, shapingFor(skill))];
-  }
-  if (input.all !== true) throw new Error("updateSkills requires a name or all=true");
-  return skills.filter((skill) => skill.provenance?.installUrl).map((skill) => updateOne(skill, input.force === true, shapingFor(skill)));
-}
-
-export {
-  parseSkillSourceSpec,
-  updateSkills,
-  MARKETPLACE_UNCONFIGURED,
-  discoverMarketplaceSkills,
-  getMarketplaceSkills,
-  marketplaceInstallShaping,
-  resolveMarketplaceShaping,
-  installSkill,
-  projectCompatTrusted,
-  defaultSkillRoots,
-  loadSkills,
-  modelVisibleSkills,
-  skillCatalogValidity,
-  SKILL_SURFACE_CLEAR_ARG,
-  parseSkillCommand,
-  expandSkillInvocationInput,
-  parsePendingSkillRequests
-};
-//# sourceMappingURL=chunk-536HXRFE.js.map