zidane 1.8.0 → 2.0.1

package/dist/chunk-BCXXXJ3G.js

@@ -0,0 +1,779 @@
+import {
+  AgentToolNotAllowedError
+} from "./chunk-7JTBBZ2U.js";
+
+// src/skills/activation.ts
+function createSkillActivationState(options = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  const maxActive = typeof options.maxActive === "number" && options.maxActive > 0 ? options.maxActive : void 0;
+  return {
+    active() {
+      return [...byName.values()];
+    },
+    isActive(name) {
+      return byName.has(name);
+    },
+    get(name) {
+      return byName.get(name);
+    },
+    activate(skill, via) {
+      if (byName.has(skill.name))
+        return "already-active";
+      if (maxActive !== void 0 && byName.size >= maxActive)
+        return "cap-reached";
+      byName.set(skill.name, {
+        skill,
+        activatedAt: Date.now(),
+        activatedVia: via
+      });
+      return "ok";
+    },
+    deactivate(name) {
+      const existing = byName.get(name);
+      if (!existing)
+        return void 0;
+      byName.delete(name);
+      return existing;
+    },
+    clear() {
+      const snapshot = [...byName.values()];
+      byName.clear();
+      return snapshot;
+    }
+  };
+}
+
+// src/skills/validate.ts
+import { basename } from "path";
+var NAME_MAX = 64;
+var DESCRIPTION_MAX = 1024;
+var COMPATIBILITY_MAX = 500;
+var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var CONSECUTIVE_HYPHENS_RE = /--/;
+var ALLOWED_TOOL_PATTERN_RE = /^([\w-]+)(?:\(([^)]*)\))?$/;
+var ABS_WINDOWS_PATH_RE = /^[a-z]:[\\/]/i;
+var PATH_SEPARATOR_RE = /[\\/]/;
+var TRAILING_SLASHES_RE = /\/+$/;
+function validateSkillName(name) {
+  if (typeof name !== "string")
+    return false;
+  if (name.length < 1 || name.length > NAME_MAX)
+    return false;
+  if (CONSECUTIVE_HYPHENS_RE.test(name))
+    return false;
+  return SKILL_NAME_RE.test(name);
+}
+function validateSkillForWrite(skill) {
+  const errors = [];
+  if (!validateSkillName(skill.name)) {
+    errors.push({
+      code: "invalid-name",
+      message: `Skill name "${skill.name}" must be 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.`,
+      field: "name"
+    });
+  }
+  if (skill.location) {
+    const dirName = basename(skill.baseDir ?? "");
+    if (dirName && dirName !== skill.name) {
+      errors.push({
+        code: "name-mismatch-directory",
+        message: `Skill name "${skill.name}" must match parent directory name "${dirName}".`,
+        field: "name"
+      });
+    }
+  }
+  if (typeof skill.description !== "string" || skill.description.length < 1) {
+    errors.push({
+      code: "missing-description",
+      message: "Skill description is required (non-empty).",
+      field: "description"
+    });
+  } else if (skill.description.length > DESCRIPTION_MAX) {
+    errors.push({
+      code: "description-too-long",
+      message: `Skill description must be at most ${DESCRIPTION_MAX} characters (got ${skill.description.length}).`,
+      field: "description"
+    });
+  }
+  if (skill.compatibility !== void 0) {
+    if (typeof skill.compatibility !== "string" || skill.compatibility.length === 0) {
+      errors.push({
+        code: "invalid-compatibility",
+        message: "Compatibility must be a non-empty string when provided.",
+        field: "compatibility"
+      });
+    } else if (skill.compatibility.length > COMPATIBILITY_MAX) {
+      errors.push({
+        code: "compatibility-too-long",
+        message: `Compatibility must be at most ${COMPATIBILITY_MAX} characters (got ${skill.compatibility.length}).`,
+        field: "compatibility"
+      });
+    }
+  }
+  if (skill.metadata) {
+    for (const [key, value] of Object.entries(skill.metadata)) {
+      if (typeof value !== "string") {
+        errors.push({
+          code: "invalid-metadata-value",
+          message: `Metadata value for "${key}" must be a string (spec: "A map from string keys to string values").`,
+          field: "metadata"
+        });
+      }
+    }
+  }
+  if (skill.allowedTools) {
+    for (const pattern of skill.allowedTools) {
+      if (!ALLOWED_TOOL_PATTERN_RE.test(pattern)) {
+        errors.push({
+          code: "invalid-allowed-tool-pattern",
+          message: `Allowed-tools entry "${pattern}" is not a recognized pattern (expected "ToolName" or "ToolName(arg:*)").`,
+          field: "allowed-tools"
+        });
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateResourcePath(relPath, baseDir) {
+  if (typeof relPath !== "string" || relPath.length === 0)
+    return { valid: false, error: "Resource path must be a non-empty string." };
+  if (relPath.includes("\0"))
+    return { valid: false, error: "Resource path contains a null byte." };
+  if (relPath.startsWith("/") || ABS_WINDOWS_PATH_RE.test(relPath))
+    return { valid: false, error: `Absolute paths are not allowed ("${relPath}").` };
+  const segments = [];
+  for (const segment of relPath.split(PATH_SEPARATOR_RE)) {
+    if (segment === "" || segment === ".")
+      continue;
+    if (segment === "..") {
+      if (segments.length === 0) {
+        return {
+          valid: false,
+          error: `Resource path "${relPath}" escapes the skill directory.`
+        };
+      }
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  if (segments.length === 0)
+    return { valid: false, error: "Resource path resolves to the skill root itself." };
+  const absolutePath = `${baseDir.replace(TRAILING_SLASHES_RE, "")}/${segments.join("/")}`;
+  return { valid: true, absolutePath };
+}
+function parseAllowedToolPattern(entry) {
+  const m = entry.trim().match(ALLOWED_TOOL_PATTERN_RE);
+  if (!m)
+    return null;
+  const tool = m[1];
+  const arg = m[2];
+  if (!arg)
+    return { tool };
+  if (arg.endsWith(":*"))
+    return { tool, argPrefix: arg.slice(0, -2) };
+  return { tool, argPrefix: arg };
+}
+function matchesAllowedTool(displayName, input, pattern) {
+  const parsed = parseAllowedToolPattern(pattern);
+  if (!parsed)
+    return false;
+  if (parsed.tool !== displayName)
+    return false;
+  if (parsed.argPrefix === void 0)
+    return true;
+  for (const value of Object.values(input)) {
+    if (typeof value === "string" && value.startsWith(parsed.argPrefix))
+      return true;
+  }
+  return false;
+}
+function isToolAllowedByUnion(displayName, input, union) {
+  if (union.length === 0)
+    return true;
+  return union.some((pattern) => matchesAllowedTool(displayName, input, pattern));
+}
+
+// src/skills/allowed-tools.ts
+var IMPLICITLY_ALLOWED_SKILL_TOOLS = [
+  "skills_use",
+  "skills_read",
+  "skills_run_script"
+];
+function installAllowedToolsGate(hooks, state) {
+  function effectiveUnion() {
+    const active = state.active();
+    const declared = [];
+    for (const record of active) {
+      if (record.skill.allowedTools?.length)
+        declared.push(...record.skill.allowedTools);
+    }
+    return {
+      union: declared.length > 0 ? [...declared, ...IMPLICITLY_ALLOWED_SKILL_TOOLS] : [],
+      active: active.map((a) => a.skill.name)
+    };
+  }
+  function gateHandler(ctx) {
+    const { union, active } = effectiveUnion();
+    if (union.length === 0)
+      return;
+    if (isToolAllowedByUnion(ctx.displayName, ctx.input, union))
+      return;
+    const err = new AgentToolNotAllowedError({
+      toolName: ctx.name,
+      displayName: ctx.displayName,
+      allowedUnion: union,
+      activeSkills: active
+    });
+    ctx.block = true;
+    ctx.reason = err.message;
+  }
+  function mcpGateHandler(ctx) {
+    const { union, active } = effectiveUnion();
+    if (union.length === 0)
+      return;
+    if (isToolAllowedByUnion(ctx.displayName, ctx.input, union))
+      return;
+    const err = new AgentToolNotAllowedError({
+      toolName: `mcp_${ctx.server}_${ctx.tool}`,
+      displayName: ctx.displayName,
+      allowedUnion: union,
+      activeSkills: active
+    });
+    ctx.block = true;
+    ctx.reason = err.message;
+  }
+  const unregisterTool = hooks.hook("tool:gate", gateHandler);
+  const unregisterMcp = hooks.hook("mcp:tool:gate", mcpGateHandler);
+  return function uninstall() {
+    unregisterTool();
+    unregisterMcp();
+  };
+}
+
+// src/skills/catalog.ts
+function buildCatalog(skills, optionsOrReadToolName = {}) {
+  if (skills.length === 0)
+    return "";
+  const options = typeof optionsOrReadToolName === "string" ? { skillsToolRegistered: false, readToolName: optionsOrReadToolName } : optionsOrReadToolName;
+  const skillsToolRegistered = options.skillsToolRegistered ?? true;
+  const readToolName = options.readToolName ?? "read_file";
+  const entries = skills.map((skill) => {
+    const locationLine = skill.location ? `
+    <location>${escapeXml(skill.location)}</location>` : "";
+    return `  <skill>
+    <name>${escapeXml(skill.name)}</name>
+    <description>${escapeXml(skill.description)}</description>${locationLine}
+  </skill>`;
+  }).join("\n");
+  const hasFsSkills = skills.some((s) => s.location);
+  const hasInlineSkills = skills.some((s) => !s.location);
+  const behavioralParts = [];
+  behavioralParts.push(
+    "The following skills provide specialized instructions for specific tasks.",
+    "When a task matches a skill's description, activate the skill to load its full instructions before proceeding."
+  );
+  if (skillsToolRegistered) {
+    behavioralParts.push(
+      "To activate a skill, call the `skills_use` tool with the skill's name. The response contains the full instructions and any bundled resources you can then load via `skills_read` (reference files) or execute via `skills_run_script` (scripts/ directory).",
+      "Relative paths referenced in a skill's instructions resolve against the skill directory noted in the `skills_use` response."
+    );
+  } else if (hasFsSkills) {
+    behavioralParts.push(
+      `For skills with a <location>, use the ${readToolName} tool to read the SKILL.md file at that path.`,
+      "When a skill references relative paths, resolve them against the skill's directory (the parent of SKILL.md) and use absolute paths in tool calls."
+    );
+  }
+  if (hasInlineSkills && !skillsToolRegistered) {
+    behavioralParts.push(
+      "Skills without a <location> have their instructions included directly in <instructions> tags below."
+    );
+  }
+  const parts = [
+    behavioralParts.join("\n"),
+    "",
+    "<available_skills>",
+    entries,
+    "</available_skills>"
+  ];
+  if (hasInlineSkills && !skillsToolRegistered) {
+    parts.push("");
+    for (const skill of skills) {
+      if (!skill.location && skill.instructions) {
+        parts.push(`<skill_instructions name="${escapeXml(skill.name)}">`);
+        parts.push(skill.instructions);
+        if (skill.resources && skill.resources.length > 0) {
+          parts.push("");
+          parts.push("<skill_resources>");
+          for (const res of skill.resources) {
+            parts.push(`  <file type="${res.type}">${escapeXml(res.path)}</file>`);
+          }
+          parts.push("</skill_resources>");
+        }
+        parts.push("</skill_instructions>");
+      }
+    }
+  }
+  return parts.join("\n");
+}
+var RE_AMP = /&/g;
+var RE_LT = /</g;
+var RE_GT = />/g;
+var RE_QUOT = /"/g;
+function escapeXml(str) {
+  return str.replace(RE_AMP, "&amp;").replace(RE_LT, "&lt;").replace(RE_GT, "&gt;").replace(RE_QUOT, "&quot;");
+}
+
+// src/skills/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename as basename2, dirname, join, resolve } from "path";
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+var INDENT_RE = /^[ \t]{2,}/;
+var KV_RE = /^([^:]+):(.*)$/;
+var QUOTE_RE = /^(['"])(.*)\1$/;
+var WHITESPACE_SPLIT_RE = /\s+/;
+var PARAGRAPH_SPLIT_RE = /\n\n/;
+var COMMA_OR_SPACE_RE = /[,\s]+/;
+function parseFrontmatter(content) {
+  const diagnostics = [];
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) {
+    return { frontmatter: {}, body: content.trim(), diagnostics };
+  }
+  const yamlBlock = match[1];
+  const body = match[2].trim();
+  const frontmatter = {};
+  let currentKey = null;
+  let currentMap = null;
+  for (const line of yamlBlock.split("\n")) {
+    if (!line.trim() || line.trim().startsWith("#"))
+      continue;
+    if (currentKey && currentMap && INDENT_RE.test(line)) {
+      const nestedMatch = line.trim().match(KV_RE);
+      if (nestedMatch) {
+        const val = nestedMatch[2].trim();
+        currentMap[nestedMatch[1].trim()] = unquoteYaml(val);
+      }
+      continue;
+    }
+    if (currentKey && currentMap) {
+      frontmatter[currentKey] = currentMap;
+      currentKey = null;
+      currentMap = null;
+    }
+    const kvMatch = matchFirstColon(line);
+    if (!kvMatch)
+      continue;
+    const key = kvMatch.key.trim();
+    const rawValue = kvMatch.value.trim();
+    if (!rawValue) {
+      currentKey = key;
+      currentMap = {};
+    } else {
+      frontmatter[key] = unquoteYaml(rawValue);
+    }
+  }
+  if (currentKey && currentMap) {
+    frontmatter[currentKey] = currentMap;
+  }
+  return { frontmatter, body, diagnostics };
+}
+function matchFirstColon(line) {
+  const idx = line.indexOf(":");
+  if (idx < 0)
+    return null;
+  const key = line.slice(0, idx);
+  const value = line.slice(idx + 1);
+  if (!KV_RE.test(`${key}:`))
+    return null;
+  return { key, value };
+}
+function unquoteYaml(val) {
+  const m = val.match(QUOTE_RE);
+  if (m)
+    return m[2];
+  return val;
+}
+var RESOURCE_DIRS = {
+  scripts: "script",
+  references: "reference",
+  assets: "asset"
+};
+function enumerateResources(baseDir) {
+  const resources = [];
+  for (const [dir, type] of Object.entries(RESOURCE_DIRS)) {
+    const dirPath = join(baseDir, dir);
+    if (!existsSync(dirPath) || !statSync(dirPath).isDirectory())
+      continue;
+    try {
+      const files = readdirSync(dirPath, { recursive: true });
+      for (const file of files) {
+        const fullPath = join(dirPath, file);
+        if (statSync(fullPath).isFile()) {
+          resources.push({ path: join(dir, file), type });
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    for (const entry of readdirSync(baseDir)) {
+      if (entry === "SKILL.md")
+        continue;
+      const entryPath = join(baseDir, entry);
+      if (statSync(entryPath).isFile()) {
+        resources.push({ path: entry, type: "other" });
+      }
+    }
+  } catch {
+  }
+  return resources;
+}
+async function parseSkillFile(filePath, options = {}) {
+  const absPath = resolve(filePath);
+  if (!existsSync(absPath))
+    return null;
+  const content = readFileSync(absPath, "utf-8");
+  const { frontmatter, body, diagnostics } = parseFrontmatter(content);
+  let description = frontmatter.description;
+  if (!description && body) {
+    const firstParagraph = body.split(PARAGRAPH_SPLIT_RE)[0]?.trim();
+    if (firstParagraph)
+      description = firstParagraph;
+  }
+  if (!description)
+    return null;
+  if (description.length > 1024) {
+    diagnostics.push({
+      severity: "warning",
+      code: "description-too-long",
+      message: `Description exceeds spec limit of 1024 characters (got ${description.length}). Loading anyway.`,
+      field: "description"
+    });
+  }
+  const baseDir = dirname(absPath);
+  const dirName = basename2(baseDir);
+  const name = frontmatter.name || dirName;
+  if (frontmatter.name && frontmatter.name !== dirName) {
+    diagnostics.push({
+      severity: "warning",
+      code: "name-mismatch-directory",
+      message: `Skill name "${frontmatter.name}" does not match parent directory "${dirName}". Loading anyway.`,
+      field: "name"
+    });
+  }
+  if (name.length > 64) {
+    diagnostics.push({
+      severity: "warning",
+      code: "name-too-long",
+      message: `Skill name "${name}" exceeds spec limit of 64 characters. Loading anyway.`,
+      field: "name"
+    });
+  }
+  if (!validateSkillName(name)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "invalid-name-format",
+      message: `Skill name "${name}" does not match spec format (lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens). Loading anyway.`,
+      field: "name"
+    });
+  }
+  const config = {
+    name,
+    description,
+    instructions: body,
+    source: options.source ?? "project",
+    location: absPath,
+    baseDir,
+    resources: enumerateResources(baseDir)
+  };
+  if (frontmatter.license)
+    config.license = frontmatter.license;
+  if (frontmatter.compatibility) {
+    const comp = frontmatter.compatibility;
+    if (comp.length > 500) {
+      diagnostics.push({
+        severity: "warning",
+        code: "compatibility-too-long",
+        message: `Compatibility exceeds spec limit of 500 characters (got ${comp.length}). Loading anyway.`,
+        field: "compatibility"
+      });
+    }
+    config.compatibility = comp;
+  }
+  const metadata = {};
+  if (frontmatter.metadata && typeof frontmatter.metadata === "object") {
+    for (const [k, v] of Object.entries(frontmatter.metadata)) {
+      if (typeof v !== "string") {
+        diagnostics.push({
+          severity: "warning",
+          code: "invalid-metadata-value",
+          message: `Metadata value for "${k}" is not a string; coerced. (Spec requires string values.)`,
+          field: "metadata"
+        });
+        metadata[k] = String(v);
+        continue;
+      }
+      metadata[k] = v;
+    }
+  }
+  if (frontmatter.paths) {
+    const raw = frontmatter.paths;
+    const normalized = raw.split(COMMA_OR_SPACE_RE).filter(Boolean).join(",");
+    metadata["zidane.paths"] = normalized;
+    diagnostics.push({
+      severity: "warning",
+      code: "deprecated-top-level-field",
+      message: '`paths` is not a spec field and is deprecated \u2014 moved to `metadata["zidane.paths"]`.',
+      field: "paths"
+    });
+  }
+  if (frontmatter.model) {
+    metadata["zidane.model"] = frontmatter.model;
+    diagnostics.push({
+      severity: "warning",
+      code: "deprecated-top-level-field",
+      message: '`model` is not a spec field and is deprecated \u2014 moved to `metadata["zidane.model"]`.',
+      field: "model"
+    });
+  }
+  const legacyThinking = frontmatter.thinking ?? frontmatter.effort;
+  if (legacyThinking) {
+    metadata["zidane.thinking"] = legacyThinking;
+    diagnostics.push({
+      severity: "warning",
+      code: "deprecated-top-level-field",
+      message: `\`${frontmatter.thinking ? "thinking" : "effort"}\` is not a spec field and is deprecated \u2014 moved to \`metadata["zidane.thinking"]\`.`,
+      field: frontmatter.thinking ? "thinking" : "effort"
+    });
+  }
+  if (Object.keys(metadata).length > 0)
+    config.metadata = metadata;
+  if (frontmatter["allowed-tools"]) {
+    config.allowedTools = frontmatter["allowed-tools"].split(WHITESPACE_SPLIT_RE).filter(Boolean);
+  }
+  if (diagnostics.length > 0)
+    config.diagnostics = diagnostics;
+  return config;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "dist", "build"]);
+function findSkillDirs(root, maxDepth = 4, _depth = 0) {
+  if (_depth > maxDepth)
+    return [];
+  if (!existsSync(root) || !statSync(root).isDirectory())
+    return [];
+  const results = [];
+  try {
+    for (const entry of readdirSync(root)) {
+      if (SKIP_DIRS.has(entry))
+        continue;
+      const entryPath = join(root, entry);
+      if (!statSync(entryPath).isDirectory())
+        continue;
+      const skillFile = join(entryPath, "SKILL.md");
+      if (existsSync(skillFile) && statSync(skillFile).isFile()) {
+        results.push(skillFile);
+      } else {
+        results.push(...findSkillDirs(entryPath, maxDepth, _depth + 1));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function getDefaultScanPaths() {
+  const home = homedir();
+  const cwd = process.cwd();
+  return [
+    // Project-level (higher priority)
+    { path: join(cwd, ".agents", "skills"), source: "project" },
+    { path: join(cwd, ".zidane", "skills"), source: "project" },
+    // User-level (lower priority)
+    { path: join(home, ".agents", "skills"), source: "user" },
+    { path: join(home, ".zidane", "skills"), source: "user" }
+  ];
+}
+function inferSource(path) {
+  return path.startsWith(homedir()) ? "user" : "project";
+}
+async function discoverSkills(paths) {
+  const skillsByName = /* @__PURE__ */ new Map();
+  for (const { path: scanPath, source } of paths) {
+    const skillFiles = findSkillDirs(resolve(scanPath));
+    for (const file of skillFiles) {
+      const skill = await parseSkillFile(file, { source });
+      if (!skill)
+        continue;
+      if (skillsByName.has(skill.name)) {
+        const existing = skillsByName.get(skill.name);
+        const diag = {
+          severity: "warning",
+          code: "name-collision-shadowed",
+          message: `A skill with name "${skill.name}" was also found at ${file} (source: ${source}); shadowed by ${existing.location} (source: ${existing.source}).`
+        };
+        existing.diagnostics = [...existing.diagnostics ?? [], diag];
+        continue;
+      }
+      skillsByName.set(skill.name, skill);
+    }
+  }
+  return [...skillsByName.values()];
+}
+
+// src/skills/writer.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var YAML_RESERVED_RE = /[:#&*!|>%@`]/;
+var YAML_EDGE_OR_QUOTE_RE = /^\s|\s$|["']/;
+var DQUOTE_RE = /"/g;
+function yamlEscape(value) {
+  if (YAML_RESERVED_RE.test(value) || YAML_EDGE_OR_QUOTE_RE.test(value) || value === "")
+    return `"${value.replace(DQUOTE_RE, '\\"')}"`;
+  return value;
+}
+function serializeFrontmatter(skill) {
+  const lines = ["---"];
+  lines.push(`name: ${yamlEscape(skill.name)}`);
+  lines.push(`description: ${yamlEscape(skill.description)}`);
+  if (skill.license)
+    lines.push(`license: ${yamlEscape(skill.license)}`);
+  if (skill.compatibility)
+    lines.push(`compatibility: ${yamlEscape(skill.compatibility)}`);
+  if (skill.allowedTools?.length)
+    lines.push(`allowed-tools: ${skill.allowedTools.join(" ")}`);
+  if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+    lines.push("metadata:");
+    for (const [key, value] of Object.entries(skill.metadata)) {
+      lines.push(`  ${key}: "${value.replace(DQUOTE_RE, '\\"')}"`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function writeSkillToDisk(skill, targetDir) {
+  const result = validateSkillForWrite(skill);
+  if (!result.valid) {
+    const summary = result.errors.map((e) => `  - [${e.code}] ${e.message}`).join("\n");
+    throw new Error(`Cannot write invalid skill "${skill.name}":
+${summary}`);
+  }
+  const skillDir = join2(targetDir, skill.name);
+  mkdirSync(skillDir, { recursive: true });
+  const frontmatter = serializeFrontmatter(skill);
+  const body = skill.instructions ? `
+${skill.instructions}` : "";
+  const content = `${frontmatter}
+${body}
+`;
+  const skillPath = join2(skillDir, "SKILL.md");
+  writeFileSync(skillPath, content);
+  return skillPath;
+}
+function writeSkillsToDisk(skills, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  for (const skill of skills) {
+    writeSkillToDisk(skill, targetDir);
+  }
+  return targetDir;
+}
+
+// src/skills/resolve.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+async function resolveSkills(config) {
+  const sourcedPaths = [];
+  if (!config.skipDefaultPaths) {
+    sourcedPaths.push(...getDefaultScanPaths());
+  }
+  for (const p of config.scan ?? []) {
+    sourcedPaths.push({ path: p, source: inferSource(p) });
+  }
+  if (config.write?.length) {
+    const writeDir = mkdtempSync(join3(tmpdir(), "zidane-skills-"));
+    writeSkillsToDisk(config.write, writeDir);
+    sourcedPaths.push({ path: writeDir, source: "inline" });
+  }
+  let skills = await discoverSkills(sourcedPaths);
+  if (config.trustProjectSkills === false) {
+    skills = skills.filter((s) => s.source !== void 0 && s.source !== "project");
+  }
+  const exclude = new Set(config.exclude ?? []);
+  let filtered = skills.filter((s) => !exclude.has(s.name));
+  if (Array.isArray(config.enabled)) {
+    const allowlist = new Set(config.enabled);
+    filtered = filtered.filter((s) => allowlist.has(s.name));
+  }
+  return filtered;
+}
+function mergeSkillsConfig(harness, agent) {
+  if (!harness && !agent)
+    return void 0;
+  if (!harness)
+    return agent;
+  if (!agent)
+    return harness;
+  return {
+    // Agent-level takes precedence when explicitly set
+    enabled: agent.enabled !== void 0 ? agent.enabled : harness.enabled,
+    scan: [...harness.scan ?? [], ...agent.scan ?? []],
+    write: [...harness.write ?? [], ...agent.write ?? []],
+    exclude: [.../* @__PURE__ */ new Set([...harness.exclude ?? [], ...agent.exclude ?? []])],
+    skipDefaultPaths: agent.skipDefaultPaths ?? harness.skipDefaultPaths,
+    tool: agent.tool ?? harness.tool,
+    maxActive: agent.maxActive ?? harness.maxActive,
+    scriptTimeoutMs: agent.scriptTimeoutMs ?? harness.scriptTimeoutMs,
+    trustProjectSkills: agent.trustProjectSkills ?? harness.trustProjectSkills
+  };
+}
+
+// src/skills/interpolate.ts
+var SHELL_INTERPOLATION_RE = /!`([^`]+)`/g;
+async function interpolateShellCommands(instructions, execution, handle) {
+  const matches = [...instructions.matchAll(SHELL_INTERPOLATION_RE)];
+  if (matches.length === 0)
+    return instructions;
+  const replacements = [];
+  for (const match of matches) {
+    const command = match[1];
+    const index = match.index;
+    const length = match[0].length;
+    try {
+      const result2 = await execution.exec(handle, command, { timeout: 30 });
+      const output = result2.exitCode === 0 ? result2.stdout.trim() : `[command failed (exit ${result2.exitCode}): ${result2.stderr.trim() || result2.stdout.trim()}]`;
+      replacements.push({ index, length, output });
+    } catch (err) {
+      replacements.push({ index, length, output: `[command error: ${err.message}]` });
+    }
+  }
+  let result = instructions;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const { index, length, output } = replacements[i];
+    result = result.slice(0, index) + output + result.slice(index + length);
+  }
+  return result;
+}
+
+export {
+  createSkillActivationState,
+  validateSkillName,
+  validateSkillForWrite,
+  validateResourcePath,
+  parseAllowedToolPattern,
+  matchesAllowedTool,
+  isToolAllowedByUnion,
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
+  installAllowedToolsGate,
+  buildCatalog,
+  parseFrontmatter,
+  parseSkillFile,
+  getDefaultScanPaths,
+  inferSource,
+  discoverSkills,
+  writeSkillToDisk,
+  writeSkillsToDisk,
+  resolveSkills,
+  mergeSkillsConfig,
+  interpolateShellCommands
+};