@iowarp/clio-coder 0.3.0

package/dist/chunk-26BZQOAD.js

@@ -0,0 +1,1281 @@
+import {
+  ToolNames
+} from "./chunk-QV47YRF4.js";
+import {
+  enabledExtensionResourceRoots
+} from "./chunk-CLJ5HLUD.js";
+import {
+  fsyncDirectory
+} from "./chunk-VPAWTYLY.js";
+import {
+  clioConfigDir
+} from "./chunk-X3NE4WVW.js";
+
+// src/domains/resources/skills/install.ts
+import { execFileSync } from "node:child_process";
+import {
+  cpSync,
+  existsSync as existsSync4,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import path4 from "node:path";
+
+// src/domains/resources/skills/content-hash.ts
+import { createHash } from "node:crypto";
+var PROVENANCE_KEYS = /* @__PURE__ */ new Set([
+  "source-url",
+  "sourceUrl",
+  "install-url",
+  "installed-at",
+  "installedAt",
+  "updated-at",
+  "updatedAt",
+  "installed-hash",
+  "installedHash",
+  "audit"
+]);
+function frontmatterRegion(rawText) {
+  const opening = rawText.match(/^---\r?\n/);
+  if (!opening) return null;
+  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
+  closeRegex.lastIndex = opening[0].length;
+  const closing = closeRegex.exec(rawText);
+  if (!closing) return null;
+  const frontmatterText = rawText.slice(opening[0].length, closing.index);
+  return {
+    head: opening[0],
+    lines: frontmatterText.split(/\r?\n/),
+    tail: rawText.slice(closing.index)
+  };
+}
+function stripProvenanceLines(lines) {
+  const kept = [];
+  let dropIndent = null;
+  let inClioBlock = false;
+  for (const line of lines) {
+    const indent = line.length - line.trimStart().length;
+    if (dropIndent !== null && line.trim().length > 0 && indent > dropIndent) continue;
+    dropIndent = null;
+    const keyMatch = line.match(/^([ \t]*)([A-Za-z][A-Za-z0-9-]*):/);
+    const key = keyMatch?.[2];
+    if (key !== void 0) {
+      if (indent === 0) inClioBlock = key === "clio";
+      if (PROVENANCE_KEYS.has(key) && (indent === 0 || inClioBlock)) {
+        dropIndent = indent;
+        continue;
+      }
+    }
+    kept.push(line);
+  }
+  return kept.filter((line, index) => {
+    if (!/^clio:\s*$/.test(line)) return true;
+    for (let next = index + 1; next < kept.length; next += 1) {
+      const candidate = kept[next];
+      if (candidate.trim().length === 0) continue;
+      return /^[ \t]/.test(candidate);
+    }
+    return false;
+  });
+}
+function stripProvenanceFrontmatter(rawText) {
+  const region = frontmatterRegion(rawText);
+  if (!region) return rawText;
+  return `${region.head}${stripProvenanceLines(region.lines).join("\n")}${region.tail}`;
+}
+function normalizedSkillHash(rawText) {
+  return createHash("sha256").update(stripProvenanceFrontmatter(rawText), "utf8").digest("hex");
+}
+
+// src/domains/resources/skills/loader.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync2, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import path3 from "node:path";
+
+// src/domains/resources/common-loader.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+function defaultScopedResourceRoots(kind, cwd) {
+  return [
+    ...enabledExtensionResourceRoots(kind, cwd).map((root) => ({
+      path: root.path,
+      scope: "package",
+      source: root.source
+    })),
+    { path: path.join(clioConfigDir(), kind), scope: "user", source: "config" },
+    { path: path.join(cwd, ".clio-coder", kind), scope: "project", source: "project" }
+  ];
+}
+function sourceInfoForRoot(root, filePath) {
+  return {
+    path: filePath,
+    scope: root.scope,
+    ...root.source ? { source: root.source } : {}
+  };
+}
+function readRootEntries(root, label, diagnostics) {
+  if (!existsSync(root.path)) return [];
+  let stat;
+  try {
+    stat = statSync(root.path);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({
+      type: "warning",
+      message: `${label} root could not be stat'ed: ${reason}`,
+      path: root.path
+    });
+    return [];
+  }
+  if (!stat.isDirectory()) {
+    diagnostics.push({ type: "warning", message: `${label} root is not a directory`, path: root.path });
+    return [];
+  }
+  try {
+    return readdirSync(root.path, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({ type: "warning", message: `${label} root could not be read: ${reason}`, path: root.path });
+    return [];
+  }
+}
+function splitYamlFrontmatter(raw) {
+  const opening = raw.match(/^---\r?\n/);
+  if (!opening) return { ok: false, reason: "missing", body: raw };
+  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
+  closeRegex.lastIndex = opening[0].length;
+  const closing = closeRegex.exec(raw);
+  if (!closing) return { ok: false, reason: "missing closing delimiter", body: raw };
+  const body = raw.slice(closing.index + closing[0].length);
+  const frontmatterText = raw.slice(opening[0].length, closing.index);
+  let parsed;
+  try {
+    parsed = parseYaml(frontmatterText);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `invalid YAML: ${reason}`, body };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, reason: "must be a YAML object", body };
+  }
+  return {
+    ok: true,
+    frontmatter: parsed,
+    body
+  };
+}
+function stringField(frontmatter, key) {
+  const value = frontmatter[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+// src/domains/resources/skills/marketplace.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync } from "node:fs";
+import path2 from "node:path";
+var MARKETPLACE_UNCONFIGURED = "no local skill marketplace catalog or index configured";
+function defaultIndexPath() {
+  try {
+    return path2.join(clioConfigDir(), "skill-marketplace.json");
+  } catch {
+    return 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 indexAudit(value) {
+  return value === "pass" || value === "warn" || value === "fail" || value === "unknown" ? value : void 0;
+}
+function indexSkills(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).map((skill) => {
+      const record = skill;
+      const version = optionalString(record.version);
+      const audit = indexAudit(record.audit);
+      const category = optionalString(record.category);
+      return {
+        name: skill.name.trim(),
+        description: skill.description.trim(),
+        sourceUrl: skill.sourceUrl.trim(),
+        ...version ? { version } : {},
+        ...audit ? { audit } : {},
+        ...category ? { category } : {},
+        origin: "index"
+      };
+    });
+  } catch (err) {
+    diagnostics.push(`skill marketplace index unreadable: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+}
+function looksLikeSkillCatalog(dir) {
+  if (!existsSync2(dir)) return false;
+  try {
+    return readdirSync2(dir, { withFileTypes: true }).some((entry) => {
+      if (!entry.isDirectory()) return false;
+      const child = path2.join(dir, entry.name);
+      if (existsSync2(path2.join(child, "SKILL.md"))) return true;
+      try {
+        return readdirSync2(child, { withFileTypes: true }).some(
+          (inner) => inner.isDirectory() && existsSync2(path2.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 path2.resolve(options.catalogDir);
+  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
+  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv.trim());
+  const repoCatalog = path2.join(options.cwd ?? process.cwd(), "skills");
+  return looksLikeSkillCatalog(repoCatalog) ? repoCatalog : null;
+}
+function catalogCategory(catalogDir, baseDir) {
+  const rel = path2.relative(catalogDir, baseDir);
+  const category = path2.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);
+  return {
+    name: skill.name,
+    description: skill.description,
+    sourceUrl: skill.baseDir,
+    ...version ? { version } : {},
+    ...skill.provenance?.audit ? { audit: skill.provenance.audit } : {},
+    ...category ? { category } : {},
+    origin: "catalog"
+  };
+}
+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 catalogDir = resolveCatalogDir(options);
+  if (catalogDir) {
+    for (const skill of catalogSkills(catalogDir, diagnostics)) {
+      if (seen.has(skill.name)) continue;
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  const indexPath = options.indexPath === null ? null : options.indexPath ?? process.env.CLIO_CODER_SKILL_MARKETPLACE_INDEX ?? null;
+  const resolvedIndexPath = indexPath ?? defaultIndexPath();
+  if (options.indexPath !== null && resolvedIndexPath && existsSync2(resolvedIndexPath)) {
+    for (const skill of indexSkills(resolvedIndexPath, diagnostics)) {
+      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 installSkill(input) {
+  const source = input.source.trim();
+  const spec = parseSkillSourceSpec(source);
+  if (spec?.kind === "local" && isSkillName(source) && !existsSync2(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, source: skill.sourceUrl });
+  }
+  return installSkillFromSource(input);
+}
+
+// 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 createHash2("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(input) {
+  if (input.trustProjectCompatRoots === true) return true;
+  return process.env.CLIO_CODER_TRUST_PROJECT_SKILLS === "1";
+}
+function defaultSkillRoots(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const home = input.home ?? homedir();
+  const configDir = input.configDir ?? clioConfigDirSafe();
+  const trustProject = projectCompatTrusted(input);
+  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
+    });
+  }
+  roots.push({
+    path: path3.join(home, ".agents", "skills"),
+    scope: "user",
+    source: "agents",
+    origin: "agents-user",
+    precedence: SKILL_PRECEDENCE.userCompat,
+    trusted: true,
+    containment: home
+  });
+  roots.push({
+    path: path3.join(home, ".claude", "skills"),
+    scope: "user",
+    source: "claude",
+    origin: "claude-user",
+    precedence: SKILL_PRECEDENCE.userCompat,
+    trusted: true,
+    containment: home
+  });
+  roots.push({
+    path: path3.join(home, ".codex", "skills"),
+    scope: "user",
+    source: "codex",
+    origin: "codex-user",
+    precedence: SKILL_PRECEDENCE.userCompat,
+    trusted: true,
+    containment: home
+  });
+  roots.push({
+    path: path3.join(home, ".config", "opencode", "skills"),
+    scope: "user",
+    source: "opencode",
+    origin: "opencode-user",
+    precedence: SKILL_PRECEDENCE.userCompat,
+    trusted: true,
+    containment: home
+  });
+  roots.push({
+    path: path3.join(home, ".copilot", "skills"),
+    scope: "user",
+    source: "copilot",
+    origin: "copilot-user",
+    precedence: SKILL_PRECEDENCE.userCompat,
+    trusted: true,
+    containment: home
+  });
+  if (configDir) {
+    roots.push({
+      path: path3.join(configDir, "skills"),
+      scope: "user",
+      source: "clio",
+      origin: "config",
+      precedence: SKILL_PRECEDENCE.user,
+      trusted: true,
+      containment: home
+    });
+  }
+  roots.push({
+    path: path3.join(cwd, ".agents", "skills"),
+    scope: "project",
+    source: "agents",
+    origin: "agents-project",
+    precedence: SKILL_PRECEDENCE.projectCompat,
+    trusted: trustProject,
+    containment: cwd
+  });
+  roots.push({
+    path: path3.join(cwd, ".claude", "skills"),
+    scope: "project",
+    source: "claude",
+    origin: "claude-project",
+    precedence: SKILL_PRECEDENCE.projectCompat,
+    trusted: trustProject,
+    containment: cwd
+  });
+  roots.push({
+    path: path3.join(cwd, ".codex", "skills"),
+    scope: "project",
+    source: "codex",
+    origin: "codex-project",
+    precedence: SKILL_PRECEDENCE.projectCompat,
+    trusted: trustProject,
+    containment: cwd
+  });
+  roots.push({
+    path: path3.join(cwd, ".opencode", "skills"),
+    scope: "project",
+    source: "opencode",
+    origin: "opencode-project",
+    precedence: SKILL_PRECEDENCE.projectCompat,
+    trusted: trustProject,
+    containment: cwd
+  });
+  roots.push({
+    path: path3.join(cwd, ".github", "skills"),
+    scope: "project",
+    source: "copilot",
+    origin: "copilot-project",
+    precedence: SKILL_PRECEDENCE.projectCompat,
+    trusted: trustProject,
+    containment: cwd
+  });
+  roots.push({
+    path: path3.join(cwd, ".clio-coder", "skills"),
+    scope: "project",
+    source: "clio",
+    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 extractMetadata(frontmatter) {
+  const metadata = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (CORE_FRONTMATTER_KEYS.has(key)) continue;
+    metadata[key] = value;
+  }
+  return metadata;
+}
+function extractProvenance(frontmatter) {
+  const clioRaw = frontmatter.clio;
+  const clio = clioRaw !== null && typeof clioRaw === "object" && !Array.isArray(clioRaw) ? clioRaw : void 0;
+  const field = (...keys) => {
+    for (const key of keys) {
+      if (clio) {
+        const nested = stringField(clio, 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;
+  if (!installUrl && !registryId && !registryUrl && !installedAt && !updatedAt && !installedHash && !audit)
+    return void 0;
+  return {
+    ...installUrl ? { installUrl } : {},
+    ...registryId ? { registryId } : {},
+    ...registryUrl ? { registryUrl } : {},
+    ...installedAt ? { installedAt } : {},
+    ...updatedAt ? { updatedAt } : {},
+    ...installedHash ? { installedHash } : {},
+    ...audit ? { audit } : {}
+  };
+}
+function canonicalizePath(filePath) {
+  try {
+    return realpathSync.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 = 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 name = frontmatterName ?? pathSubject;
+  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);
+  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",
+    scope,
+    hash: sha256(raw),
+    normalizedHash: normalizedSkillHash(raw),
+    pathSubject,
+    trusted: root.trusted ?? true,
+    precedence: root.precedence ?? defaultPrecedenceForScope(scope),
+    metadata: extractMetadata(parsed.frontmatter),
+    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 = readdirSync3(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) {
+  const resolved = path3.resolve(inputPath);
+  const root = explicitSkillRoot(resolved);
+  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 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) => {
+      const delta = a.skill.precedence - b.skill.precedence;
+      if (delta !== 0) return delta;
+      return a.skill.filePath.localeCompare(b.skill.filePath);
+    });
+    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}; using the higher-precedence entry`,
+        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) => {
+      const delta = a.skill.precedence - b.skill.precedence;
+      if (delta !== 0) return delta;
+      return a.skill.filePath.localeCompare(b.skill.filePath);
+    });
+    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 parseSkillCommand(input) {
+  const trimmed = input.trim();
+  const prefix = trimmed.startsWith("/skill:") ? "/skill:" : trimmed.startsWith("/skills:") ? "/skills:" : trimmed.startsWith("/skill ") ? "/skill " : null;
+  if (!prefix) return null;
+  const rest = trimmed.slice(prefix.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 (path4.isAbsolute(filePath) || filePath.includes("\0")) return null;
+  const segments = filePath.split("/");
+  if (segments.some((segment) => segment === "..")) return null;
+  const normalized = path4.posix.normalize(filePath);
+  if (normalized.startsWith("..") || path4.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("~/") ? path4.join(homedir2(), trimmed.slice(2)) : trimmed;
+  return { kind: "local", path: path4.resolve(expanded), original: trimmed };
+}
+function yamlQuote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+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"
+  ];
+  const clioIndex = kept.findIndex((line) => /^clio:/.test(line));
+  if (clioIndex >= 0 && !/^clio:\s*$/.test(kept[clioIndex])) {
+    return `${region.head}${[...kept, ...stamps].join("\n")}${region.tail}`;
+  }
+  const nested = stamps.map((line) => `  ${line}`);
+  if (clioIndex < 0) {
+    return `${region.head}${[...kept, "clio:", ...nested].join("\n")}${region.tail}`;
+  }
+  let blockEnd = clioIndex + 1;
+  while (blockEnd < kept.length) {
+    const line = kept[blockEnd];
+    if (line.trim().length > 0 && !/^[ \t]/.test(line)) break;
+    blockEnd += 1;
+  }
+  return `${region.head}${[...kept.slice(0, blockEnd), ...nested, ...kept.slice(blockEnd)].join("\n")}${region.tail}`;
+}
+function resolveSkillDir(target) {
+  if (!existsSync4(target)) throw new Error(`skill source path does not exist: ${target}`);
+  const stat = statSync2(target);
+  if (stat.isFile()) {
+    if (!target.endsWith(".md")) throw new Error(`skill source must be a SKILL.md file or directory: ${target}`);
+    return path4.dirname(target);
+  }
+  if (!existsSync4(path4.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(path4.join(tmpdir(), "clio-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 = path4.join(tmp, spec.filePath);
+    if (!existsSync4(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) {
+  mkdirSync(path4.dirname(to), { recursive: true });
+  cpSync(from, to, {
+    recursive: true,
+    filter: (source) => {
+      const base = path4.basename(source);
+      return base !== ".git" && base !== "node_modules";
+    }
+  });
+}
+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 = existsSync4(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(path4.dirname(dest));
+}
+function destinationRoot(scope, cwd, configDir) {
+  return scope === "user" ? path4.join(configDir ?? clioConfigDir(), "skills") : path4.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 = fetchSource(spec);
+  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 = path4.join(destinationRoot(scope, cwd, input.configDir), name);
+    if (existsSync4(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 = path4.join(dest, "SKILL.md");
+    swapSkillDir((staging) => {
+      copySkillDir(fetched.skillDir, staging);
+      writeFileSync(
+        path4.join(staging, "SKILL.md"),
+        injectProvenanceFrontmatter(sourceRaw, {
+          sourceUrl: spec.original,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          installedHash
+        }),
+        "utf8"
+      );
+    }, dest);
+    const after = loadSkills({ cwd, ...scope === "user" && input.configDir ? { configDir: input.configDir } : {} });
+    const installWarnings = after.diagnostics.filter((diag) => diag.path && path4.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" && (skill.scope === "user" || skill.scope === "project"));
+}
+function updateOne(skill, force) {
+  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}` };
+  const fetched = fetchSource(spec);
+  try {
+    validateSourceSkill(fetched.skillDir);
+    const remoteFile = path4.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(
+        path4.join(staging, "SKILL.md"),
+        injectProvenanceFrontmatter(remoteRaw, {
+          sourceUrl,
+          installedAt: skill.provenance?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          installedHash: remoteHash
+        }),
+        "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);
+  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)];
+  }
+  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));
+}
+
+export {
+  defaultScopedResourceRoots,
+  sourceInfoForRoot,
+  readRootEntries,
+  splitYamlFrontmatter,
+  stringField,
+  updateSkills,
+  MARKETPLACE_UNCONFIGURED,
+  discoverMarketplaceSkills,
+  getMarketplaceSkills,
+  installSkill,
+  loadSkills,
+  modelVisibleSkills,
+  parseSkillCommand,
+  expandSkillInvocationInput,
+  parsePendingSkillRequests
+};
+//# sourceMappingURL=chunk-26BZQOAD.js.map