@agentforge/core 0.12.6 → 0.14.0

package/dist/index.js

@@ -7,6 +7,7 @@ var ToolCategory = /* @__PURE__ */ ((ToolCategory2) => {
   ToolCategory2["API"] = "api";
   ToolCategory2["UTILITY"] = "utility";
   ToolCategory2["CUSTOM"] = "custom";
+  ToolCategory2["SKILLS"] = "skills";
   return ToolCategory2;
 })(ToolCategory || {});
 
@@ -1405,7 +1406,7 @@ function createToolExecutor(config = {}) {
         }
         if (attempt < policy.maxAttempts) {
           const delay = calculateBackoff(attempt, policy);
-          await new Promise((resolve) => setTimeout(resolve, delay));
+          await new Promise((resolve3) => setTimeout(resolve3, delay));
         }
       }
     }
@@ -1462,12 +1463,12 @@ function createToolExecutor(config = {}) {
   }
   async function execute(tool, input, options = {}) {
     const priority = options.priority || priorityFn(tool);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       queue.push({
         tool,
         input,
         priority,
-        resolve,
+        resolve: resolve3,
         reject,
         timestamp: Date.now()
       });
@@ -1767,7 +1768,7 @@ function retry(tool, options = {}) {
           lastError = error;
           if (attempt < maxAttempts) {
             const waitTime = backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
+            await new Promise((resolve3) => setTimeout(resolve3, waitTime));
           }
         }
       }
@@ -1828,7 +1829,7 @@ function createMockTool(config) {
       const startTime = Date.now();
       if (latency) {
         const delay = typeof latency === "number" ? latency : Math.random() * (latency.max - latency.min) + latency.min;
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
       }
       if (errorRate > 0 && Math.random() < errorRate) {
         const error2 = new Error(`Random error from ${name}`);
@@ -1899,8 +1900,8 @@ function createToolSimulator(config) {
     if (!latency) return 0;
     const u1 = Math.random();
     const u2 = Math.random();
-    const z3 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-    return Math.max(0, latency.mean + z3 * latency.stddev);
+    const z4 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    return Math.max(0, latency.mean + z4 * latency.stddev);
   }
   return {
     execute: async (toolName, input) => {
@@ -1911,7 +1912,7 @@ function createToolSimulator(config) {
       const startTime = Date.now();
       if (latency) {
         const delay = generateLatency();
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
       }
       if (errorRate > 0 && Math.random() < errorRate) {
         const error = new Error(`Simulated error from ${toolName}`);
@@ -2269,7 +2270,7 @@ function calculateDelay(attempt, strategy, initialDelay, maxDelay) {
   return Math.min(delay, maxDelay);
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function withRetry(node, options = {}) {
   const {
@@ -2515,14 +2516,14 @@ var withLogging = (options) => {
     onComplete,
     onError
   } = options;
-  const logger5 = providedLogger || createLogger(name, { level });
+  const logger8 = providedLogger || createLogger(name, { level });
   return (node) => {
     return async (state) => {
       const startTime = Date.now();
       try {
         if (logInput) {
           const data = extractData ? extractData(state) : { state };
-          logger5.info("Node execution started", data);
+          logger8.info("Node execution started", data);
         }
         if (onStart) {
           onStart(state);
@@ -2532,9 +2533,9 @@ var withLogging = (options) => {
         if (logOutput) {
           const data = extractData ? extractData(result) : { result };
           if (logDuration) {
-            logger5.info(`Node execution completed (${duration}ms)`, data);
+            logger8.info(`Node execution completed (${duration}ms)`, data);
           } else {
-            logger5.info("Node execution completed", data);
+            logger8.info("Node execution completed", data);
           }
         }
         if (onComplete) {
@@ -2545,7 +2546,7 @@ var withLogging = (options) => {
         const duration = Date.now() - startTime;
         const err = error instanceof Error ? error : new Error(String(error));
         if (logErrors) {
-          logger5.error(`Node execution failed (${duration}ms)`, {
+          logger8.error(`Node execution failed (${duration}ms)`, {
             error: err.message,
             stack: err.stack
           });
@@ -2581,7 +2582,7 @@ function withLogging2(options) {
 function production(node, options) {
   const {
     nodeName,
-    logger: logger5,
+    logger: logger8,
     enableMetrics = true,
     enableTracing = true,
     enableRetry = true,
@@ -2589,7 +2590,7 @@ function production(node, options) {
     retryOptions = {},
     errorOptions = {}
   } = options;
-  const actualLogger = logger5 || createLogger(nodeName, { level: "info" /* INFO */ });
+  const actualLogger = logger8 || createLogger(nodeName, { level: "info" /* INFO */ });
   const middleware = [];
   middleware.push(
     withLogging2({
@@ -2653,9 +2654,9 @@ function development(node, options) {
   const {
     nodeName,
     verbose = true,
-    logger: logger5
+    logger: logger8
   } = options;
-  const actualLogger = logger5 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
+  const actualLogger = logger8 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
   return withLogging2({
     logger: actualLogger,
     name: nodeName,
@@ -2679,7 +2680,7 @@ function testing(node, options) {
       invocations.push(state);
     }
     if (delay > 0) {
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      await new Promise((resolve3) => setTimeout(resolve3, delay));
     }
     if (simulateError) {
       throw simulateError;
@@ -3138,12 +3139,12 @@ var ConcurrencyController = class {
       }
       throw new Error(`Queue is full (max size: ${this.maxQueueSize})`);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const task = {
         state,
         priority,
         executor,
-        resolve,
+        resolve: resolve3,
         reject,
         timestamp: Date.now()
       };
@@ -3608,7 +3609,7 @@ async function* throttle(stream, options) {
     const now = Date.now();
     const timeSinceLastEmit = now - lastEmit;
     if (timeSinceLastEmit < interval) {
-      await new Promise((resolve) => setTimeout(resolve, interval - timeSinceLastEmit));
+      await new Promise((resolve3) => setTimeout(resolve3, interval - timeSinceLastEmit));
     }
     lastEmit = Date.now();
     yield item;
@@ -4123,17 +4124,17 @@ var ConnectionPool = class {
       this.options.onAcquire?.(connection);
       return connection;
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const timeout2 = poolConfig.acquireTimeout || 3e4;
       const timer = setTimeout(() => {
-        const index = this.pending.findIndex((p) => p.resolve === resolve);
+        const index = this.pending.findIndex((p) => p.resolve === resolve3);
         if (index !== -1) {
           this.pending.splice(index, 1);
           this.stats.pending--;
         }
         reject(new Error("Acquire timeout"));
       }, timeout2);
-      this.pending.push({ resolve, reject, timeout: timer });
+      this.pending.push({ resolve: resolve3, reject, timeout: timer });
       this.stats.pending++;
     });
   }
@@ -4217,7 +4218,7 @@ var ConnectionPool = class {
     this.pending = [];
     this.stats.pending = 0;
     while (this.connections.some((c) => c.inUse)) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
     }
   }
   async clear() {
@@ -4544,10 +4545,10 @@ var BatchProcessor = class {
     failedBatches: 0
   };
   add(input) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       this.pending.push({
         input,
-        resolve,
+        resolve: resolve3,
         reject,
         addedAt: Date.now()
       });
@@ -5307,6 +5308,841 @@ function loadPrompt(promptName, options = {}, promptsDir) {
     );
   }
 }
+
+// src/skills/types.ts
+var TrustPolicyReason = /* @__PURE__ */ ((TrustPolicyReason2) => {
+  TrustPolicyReason2["NOT_SCRIPT"] = "not-script";
+  TrustPolicyReason2["WORKSPACE_TRUST"] = "workspace-trust";
+  TrustPolicyReason2["TRUSTED_ROOT"] = "trusted-root";
+  TrustPolicyReason2["UNTRUSTED_SCRIPT_DENIED"] = "untrusted-script-denied";
+  TrustPolicyReason2["UNTRUSTED_SCRIPT_ALLOWED"] = "untrusted-script-allowed-override";
+  TrustPolicyReason2["UNKNOWN_TRUST_LEVEL"] = "unknown-trust-level";
+  return TrustPolicyReason2;
+})(TrustPolicyReason || {});
+var SkillRegistryEvent = /* @__PURE__ */ ((SkillRegistryEvent2) => {
+  SkillRegistryEvent2["SKILL_DISCOVERED"] = "skill:discovered";
+  SkillRegistryEvent2["SKILL_WARNING"] = "skill:warning";
+  SkillRegistryEvent2["SKILL_ACTIVATED"] = "skill:activated";
+  SkillRegistryEvent2["SKILL_RESOURCE_LOADED"] = "skill:resource-loaded";
+  SkillRegistryEvent2["TRUST_POLICY_DENIED"] = "trust:policy-denied";
+  SkillRegistryEvent2["TRUST_POLICY_ALLOWED"] = "trust:policy-allowed";
+  return SkillRegistryEvent2;
+})(SkillRegistryEvent || {});
+
+// src/skills/parser.ts
+import matter from "gray-matter";
+var SKILL_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SKILL_NAME_MAX_LENGTH = 64;
+var SKILL_DESCRIPTION_MAX_LENGTH = 1024;
+function validateSkillName(name) {
+  const errors = [];
+  if (name === void 0 || name === null) {
+    errors.push({ field: "name", message: "name is required" });
+    return errors;
+  }
+  if (typeof name !== "string") {
+    errors.push({ field: "name", message: "name must be a string" });
+    return errors;
+  }
+  if (name.length === 0) {
+    errors.push({ field: "name", message: "name must not be empty" });
+    return errors;
+  }
+  if (name.length > SKILL_NAME_MAX_LENGTH) {
+    errors.push({
+      field: "name",
+      message: `name must be at most ${SKILL_NAME_MAX_LENGTH} characters (got ${name.length})`
+    });
+    return errors;
+  }
+  if (!SKILL_NAME_PATTERN.test(name)) {
+    errors.push({
+      field: "name",
+      message: "name must be lowercase alphanumeric with hyphens, no leading/trailing/consecutive hyphens"
+    });
+  }
+  if (name.includes("--")) {
+    errors.push({
+      field: "name",
+      message: "name must not contain consecutive hyphens"
+    });
+  }
+  return errors;
+}
+function validateSkillDescription(description) {
+  const errors = [];
+  if (description === void 0 || description === null) {
+    errors.push({ field: "description", message: "description is required" });
+    return errors;
+  }
+  if (typeof description !== "string") {
+    errors.push({ field: "description", message: "description must be a string" });
+    return errors;
+  }
+  if (description.trim().length === 0) {
+    errors.push({ field: "description", message: "description must not be empty" });
+    return errors;
+  }
+  if (description.length > SKILL_DESCRIPTION_MAX_LENGTH) {
+    errors.push({
+      field: "description",
+      message: `description must be at most ${SKILL_DESCRIPTION_MAX_LENGTH} characters (got ${description.length})`
+    });
+  }
+  return errors;
+}
+function validateSkillNameMatchesDir(name, dirName) {
+  if (name !== dirName) {
+    return [{
+      field: "name",
+      message: `name "${name}" must match parent directory name "${dirName}"`
+    }];
+  }
+  return [];
+}
+function parseSkillContent(content, dirName) {
+  let parsed;
+  try {
+    parsed = matter(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to parse frontmatter: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const data = parsed.data;
+  const errors = [
+    ...validateSkillName(data.name),
+    ...validateSkillDescription(data.description)
+  ];
+  if (typeof data.name === "string" && data.name.length > 0 && SKILL_NAME_PATTERN.test(data.name)) {
+    errors.push(...validateSkillNameMatchesDir(data.name, dirName));
+  }
+  if (errors.length > 0) {
+    return {
+      success: false,
+      error: errors.map((e) => `${e.field}: ${e.message}`).join("; ")
+    };
+  }
+  const metadata = {
+    name: data.name,
+    description: data.description
+  };
+  if (data.license !== void 0) {
+    metadata.license = String(data.license);
+  }
+  if (Array.isArray(data.compatibility)) {
+    metadata.compatibility = data.compatibility.map(String);
+  }
+  if (data.metadata !== void 0 && typeof data.metadata === "object" && data.metadata !== null) {
+    metadata.metadata = data.metadata;
+  }
+  if (Array.isArray(data["allowed-tools"])) {
+    metadata.allowedTools = data["allowed-tools"].map(String);
+  }
+  return {
+    success: true,
+    metadata,
+    body: parsed.content
+  };
+}
+
+// src/skills/scanner.ts
+import { existsSync, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
+import { resolve, basename } from "path";
+import { homedir } from "os";
+var logger5 = createLogger("agentforge:core:skills:scanner", { level: "info" /* INFO */ });
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function scanSkillRoot(rootPath) {
+  const resolvedRoot = resolve(expandHome(rootPath));
+  const candidates = [];
+  if (!existsSync(resolvedRoot)) {
+    logger5.debug("Skill root does not exist, skipping", { rootPath: resolvedRoot });
+    return candidates;
+  }
+  let entries;
+  try {
+    entries = readdirSync(resolvedRoot);
+  } catch (err) {
+    logger5.warn("Failed to read skill root directory", {
+      rootPath: resolvedRoot,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return candidates;
+  }
+  for (const entry of entries) {
+    const entryPath = resolve(resolvedRoot, entry);
+    let stat;
+    try {
+      stat = statSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) {
+      continue;
+    }
+    const skillMdPath = resolve(entryPath, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+      continue;
+    }
+    try {
+      const content = readFileSync2(skillMdPath, "utf-8");
+      candidates.push({
+        skillPath: entryPath,
+        dirName: basename(entryPath),
+        content,
+        rootPath: resolvedRoot
+      });
+    } catch (err) {
+      logger5.warn("Failed to read SKILL.md", {
+        path: skillMdPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  logger5.debug("Scanned skill root", {
+    rootPath: resolvedRoot,
+    candidatesFound: candidates.length
+  });
+  return candidates;
+}
+function scanAllSkillRoots(skillRoots) {
+  const allCandidates = [];
+  for (const root of skillRoots) {
+    const candidates = scanSkillRoot(root);
+    allCandidates.push(...candidates);
+  }
+  logger5.info("Skill discovery complete", {
+    rootsScanned: skillRoots.length,
+    totalCandidates: allCandidates.length
+  });
+  return allCandidates;
+}
+
+// src/skills/activation.ts
+import { readFileSync as readFileSync3, realpathSync } from "fs";
+import { resolve as resolve2, relative, isAbsolute } from "path";
+import matter2 from "gray-matter";
+import { z as z3 } from "zod";
+
+// src/skills/trust.ts
+var SCRIPT_PATH_PREFIX = "scripts/";
+var SCRIPT_PATH_EXACT = "scripts";
+function normalizeRootConfig(root) {
+  if (typeof root === "string") {
+    return { path: root, trust: "untrusted" };
+  }
+  return root;
+}
+function isScriptResource(resourcePath) {
+  let normalized = resourcePath.trim().replace(/\\/g, "/");
+  normalized = normalized.replace(/\/+/g, "/");
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  const lower = normalized.toLowerCase();
+  return lower === SCRIPT_PATH_EXACT || lower.startsWith(SCRIPT_PATH_PREFIX);
+}
+function evaluateTrustPolicy(resourcePath, trustLevel, allowUntrustedScripts = false) {
+  if (!isScriptResource(resourcePath)) {
+    return {
+      allowed: true,
+      reason: "not-script" /* NOT_SCRIPT */,
+      message: "Resource is not a script \u2014 no trust check required"
+    };
+  }
+  switch (trustLevel) {
+    case "workspace":
+      return {
+        allowed: true,
+        reason: "workspace-trust" /* WORKSPACE_TRUST */,
+        message: "Script allowed \u2014 skill root has workspace trust"
+      };
+    case "trusted":
+      return {
+        allowed: true,
+        reason: "trusted-root" /* TRUSTED_ROOT */,
+        message: "Script allowed \u2014 skill root is explicitly trusted"
+      };
+    case "untrusted":
+      if (allowUntrustedScripts) {
+        return {
+          allowed: true,
+          reason: "untrusted-script-allowed-override" /* UNTRUSTED_SCRIPT_ALLOWED */,
+          message: "Script from untrusted root allowed via allowUntrustedScripts override"
+        };
+      }
+      return {
+        allowed: false,
+        reason: "untrusted-script-denied" /* UNTRUSTED_SCRIPT_DENIED */,
+        message: `Script access denied \u2014 skill root is untrusted. Scripts from untrusted roots are blocked by default for security. To allow, set 'allowUntrustedScripts: true' in SkillRegistryConfig or promote the skill root to 'trusted' or 'workspace' trust level.`
+      };
+    default:
+      return {
+        allowed: false,
+        reason: "unknown-trust-level" /* UNKNOWN_TRUST_LEVEL */,
+        message: `Script access denied \u2014 trust level "${trustLevel}" is unknown and is treated as untrusted for security.`
+      };
+  }
+}
+
+// src/skills/activation.ts
+var logger6 = createLogger("agentforge:core:skills:activation", { level: "info" /* INFO */ });
+var activateSkillSchema = z3.object({
+  name: z3.string().describe('The name of the skill to activate (e.g., "code-review")')
+});
+var readSkillResourceSchema = z3.object({
+  name: z3.string().describe("The name of the skill that owns the resource"),
+  path: z3.string().describe('Relative path to the resource file within the skill directory (e.g., "references/GUIDE.md", "scripts/setup.sh")')
+});
+function resolveResourcePath(skillPath, resourcePath) {
+  if (isAbsolute(resourcePath)) {
+    return { success: false, error: "Absolute resource paths are not allowed" };
+  }
+  const segments = resourcePath.split(/[/\\]/);
+  if (segments.some((seg) => seg === "..")) {
+    return { success: false, error: "Path traversal is not allowed \u2014 resource paths must stay within the skill directory" };
+  }
+  const resolvedPath = resolve2(skillPath, resourcePath);
+  const resolvedSkillPath = resolve2(skillPath);
+  const rel = relative(resolvedSkillPath, resolvedPath);
+  if (rel.startsWith("..") || resolve2(resolvedSkillPath, rel) !== resolvedPath) {
+    return { success: false, error: "Path traversal is not allowed \u2014 resource paths must stay within the skill directory" };
+  }
+  try {
+    const realSkillRoot = realpathSync(resolvedSkillPath);
+    const realTarget = realpathSync(resolvedPath);
+    const realRel = relative(realSkillRoot, realTarget);
+    if (realRel.startsWith("..") || isAbsolute(realRel)) {
+      return { success: false, error: "Symlink target escapes the skill directory \u2014 access denied" };
+    }
+  } catch {
+  }
+  return { success: true, resolvedPath };
+}
+function createActivateSkillTool(registry) {
+  return new ToolBuilder().name("activate-skill").description(
+    "Activate an Agent Skill by name, loading its full instructions. Returns the complete SKILL.md body content for the named skill. Use this when you see a relevant skill in <available_skills> and want to follow its instructions."
+  ).category("skills" /* SKILLS */).tags(["skill", "activation", "agent-skills"]).schema(activateSkillSchema).implement(async ({ name }) => {
+    const skill = registry.get(name);
+    if (!skill) {
+      const availableNames = registry.getNames();
+      const suggestion = availableNames.length > 0 ? ` Available skills: ${availableNames.join(", ")}` : " No skills are currently registered.";
+      const errorMsg = `Skill "${name}" not found.${suggestion}`;
+      logger6.warn("Skill activation failed \u2014 not found", { name, availableCount: availableNames.length });
+      return errorMsg;
+    }
+    const skillMdPath = resolve2(skill.skillPath, "SKILL.md");
+    try {
+      const content = readFileSync3(skillMdPath, "utf-8");
+      const body = extractBody(content);
+      logger6.info("Skill activated", {
+        name: skill.metadata.name,
+        skillPath: skill.skillPath,
+        bodyLength: body.length
+      });
+      registry.emitEvent("skill:activated" /* SKILL_ACTIVATED */, {
+        name: skill.metadata.name,
+        skillPath: skill.skillPath,
+        bodyLength: body.length
+      });
+      return body;
+    } catch (error) {
+      const errorMsg = `Failed to read skill "${name}" instructions: ${error instanceof Error ? error.message : String(error)}`;
+      logger6.error("Skill activation failed \u2014 read error", {
+        name,
+        skillPath: skill.skillPath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return errorMsg;
+    }
+  }).build();
+}
+function createReadSkillResourceTool(registry) {
+  return new ToolBuilder().name("read-skill-resource").description(
+    "Read a resource file from an activated Agent Skill. Returns the content of a file within the skill directory (e.g., references/, scripts/, assets/). The path must be relative to the skill root and cannot traverse outside it."
+  ).category("skills" /* SKILLS */).tags(["skill", "resource", "agent-skills"]).schema(readSkillResourceSchema).implement(async ({ name, path: resourcePath }) => {
+    const skill = registry.get(name);
+    if (!skill) {
+      const availableNames = registry.getNames();
+      const suggestion = availableNames.length > 0 ? ` Available skills: ${availableNames.join(", ")}` : " No skills are currently registered.";
+      const errorMsg = `Skill "${name}" not found.${suggestion}`;
+      logger6.warn("Skill resource load failed \u2014 skill not found", { name, resourcePath });
+      return errorMsg;
+    }
+    const pathResult = resolveResourcePath(skill.skillPath, resourcePath);
+    if (!pathResult.success) {
+      logger6.warn("Skill resource load blocked \u2014 path traversal", {
+        name,
+        resourcePath,
+        error: pathResult.error
+      });
+      return pathResult.error;
+    }
+    const policyDecision = evaluateTrustPolicy(
+      resourcePath,
+      skill.trustLevel,
+      registry.getAllowUntrustedScripts()
+    );
+    if (!policyDecision.allowed) {
+      logger6.warn("Skill resource load blocked \u2014 trust policy", {
+        name,
+        resourcePath,
+        trustLevel: skill.trustLevel,
+        reason: policyDecision.reason,
+        message: policyDecision.message
+      });
+      registry.emitEvent("trust:policy-denied" /* TRUST_POLICY_DENIED */, {
+        name: skill.metadata.name,
+        resourcePath,
+        trustLevel: skill.trustLevel,
+        reason: policyDecision.reason,
+        message: policyDecision.message
+      });
+      return policyDecision.message;
+    }
+    if (policyDecision.reason !== "not-script" /* NOT_SCRIPT */) {
+      logger6.info("Skill resource trust policy \u2014 allowed", {
+        name,
+        resourcePath,
+        trustLevel: skill.trustLevel,
+        reason: policyDecision.reason
+      });
+      registry.emitEvent("trust:policy-allowed" /* TRUST_POLICY_ALLOWED */, {
+        name: skill.metadata.name,
+        resourcePath,
+        trustLevel: skill.trustLevel,
+        reason: policyDecision.reason
+      });
+    }
+    try {
+      const content = readFileSync3(pathResult.resolvedPath, "utf-8");
+      logger6.info("Skill resource loaded", {
+        name: skill.metadata.name,
+        resourcePath,
+        resolvedPath: pathResult.resolvedPath,
+        contentLength: content.length
+      });
+      registry.emitEvent("skill:resource-loaded" /* SKILL_RESOURCE_LOADED */, {
+        name: skill.metadata.name,
+        resourcePath,
+        resolvedPath: pathResult.resolvedPath,
+        contentLength: content.length
+      });
+      return content;
+    } catch (error) {
+      const errorMsg = `Failed to read resource "${resourcePath}" from skill "${name}": ${error instanceof Error ? error.message : String(error)}`;
+      logger6.warn("Skill resource load failed \u2014 file not found or unreadable", {
+        name,
+        resourcePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return errorMsg;
+    }
+  }).build();
+}
+function createSkillActivationTools(registry) {
+  return [
+    createActivateSkillTool(registry),
+    createReadSkillResourceTool(registry)
+  ];
+}
+function extractBody(content) {
+  return matter2(content).content.trim();
+}
+
+// src/skills/registry.ts
+import { resolve as resolvePath } from "path";
+var logger7 = createLogger("agentforge:core:skills:registry", { level: "info" /* INFO */ });
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  config;
+  scanErrors = [];
+  /** Maps resolved root paths → trust levels for skill trust assignment */
+  rootTrustMap = /* @__PURE__ */ new Map();
+  /**
+   * Create a SkillRegistry and immediately scan configured roots for skills.
+   *
+   * @param config - Registry configuration with skill root paths
+   *
+   * @example
+   * ```ts
+   * const registry = new SkillRegistry({
+   *   skillRoots: ['.agentskills', '~/.agentskills', './project-skills'],
+   * });
+   * console.log(`Discovered ${registry.size()} skills`);
+   * ```
+   */
+  constructor(config) {
+    this.config = config;
+    this.discover();
+  }
+  /**
+   * Scan all configured roots and populate the registry.
+   *
+   * Called automatically during construction. Can be called again
+   * to re-scan (clears existing skills first).
+   */
+  discover() {
+    this.skills.clear();
+    this.scanErrors = [];
+    this.rootTrustMap.clear();
+    const normalizedRoots = this.config.skillRoots.map(normalizeRootConfig);
+    const plainPaths = normalizedRoots.map((r) => r.path);
+    for (const root of normalizedRoots) {
+      const resolvedPath = resolvePath(expandHome(root.path));
+      this.rootTrustMap.set(resolvedPath, root.trust);
+    }
+    const candidates = scanAllSkillRoots(plainPaths);
+    let successCount = 0;
+    let warningCount = 0;
+    for (const candidate of candidates) {
+      const result = parseSkillContent(candidate.content, candidate.dirName);
+      if (!result.success) {
+        warningCount++;
+        this.scanErrors.push({
+          path: candidate.skillPath,
+          error: result.error || "Unknown parse error"
+        });
+        this.emit("skill:warning" /* SKILL_WARNING */, {
+          skillPath: candidate.skillPath,
+          rootPath: candidate.rootPath,
+          error: result.error
+        });
+        logger7.warn("Skipping invalid skill", {
+          skillPath: candidate.skillPath,
+          error: result.error
+        });
+        continue;
+      }
+      const skill = {
+        metadata: result.metadata,
+        skillPath: candidate.skillPath,
+        rootPath: candidate.rootPath,
+        trustLevel: this.rootTrustMap.get(candidate.rootPath) ?? "untrusted"
+      };
+      if (this.skills.has(skill.metadata.name)) {
+        const existing = this.skills.get(skill.metadata.name);
+        warningCount++;
+        const warningMsg = `Duplicate skill name "${skill.metadata.name}" from "${candidate.rootPath}" \u2014 keeping version from "${existing.rootPath}" (first root takes precedence)`;
+        this.scanErrors.push({
+          path: candidate.skillPath,
+          error: warningMsg
+        });
+        this.emit("skill:warning" /* SKILL_WARNING */, {
+          skillPath: candidate.skillPath,
+          rootPath: candidate.rootPath,
+          duplicateOf: existing.skillPath,
+          error: warningMsg
+        });
+        logger7.warn("Duplicate skill name, keeping first", {
+          name: skill.metadata.name,
+          kept: existing.skillPath,
+          skipped: candidate.skillPath
+        });
+        continue;
+      }
+      this.skills.set(skill.metadata.name, skill);
+      successCount++;
+      this.emit("skill:discovered" /* SKILL_DISCOVERED */, skill);
+      logger7.debug("Skill discovered", {
+        name: skill.metadata.name,
+        description: skill.metadata.description.slice(0, 80),
+        skillPath: skill.skillPath
+      });
+    }
+    logger7.info("Skill registry populated", {
+      rootsScanned: this.config.skillRoots.length,
+      skillsDiscovered: successCount,
+      warnings: warningCount
+    });
+  }
+  // ─── Query API (parallel to ToolRegistry) ──────────────────────────────
+  /**
+   * Get a skill by name.
+   *
+   * @param name - The skill name
+   * @returns The skill, or undefined if not found
+   *
+   * @example
+   * ```ts
+   * const skill = registry.get('code-review');
+   * if (skill) {
+   *   console.log(skill.metadata.description);
+   * }
+   * ```
+   */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /**
+   * Get all discovered skills.
+   *
+   * @returns Array of all skills
+   *
+   * @example
+   * ```ts
+   * const allSkills = registry.getAll();
+   * console.log(`Total skills: ${allSkills.length}`);
+   * ```
+   */
+  getAll() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * Check if a skill exists in the registry.
+   *
+   * @param name - The skill name
+   * @returns True if the skill exists
+   *
+   * @example
+   * ```ts
+   * if (registry.has('code-review')) {
+   *   console.log('Skill available!');
+   * }
+   * ```
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * Get the number of discovered skills.
+   *
+   * @returns Number of skills in the registry
+   *
+   * @example
+   * ```ts
+   * console.log(`Registry has ${registry.size()} skills`);
+   * ```
+   */
+  size() {
+    return this.skills.size;
+  }
+  /**
+   * Get all skill names.
+   *
+   * @returns Array of skill names
+   */
+  getNames() {
+    return Array.from(this.skills.keys());
+  }
+  /**
+   * Get errors/warnings from the last scan.
+   *
+   * Useful for diagnostics and observability.
+   *
+   * @returns Array of scan errors with paths
+   */
+  getScanErrors() {
+    return this.scanErrors;
+  }
+  /**
+   * Check whether untrusted script access is allowed via config override.
+   *
+   * Used by activation tools to pass the override flag to trust policy checks.
+   *
+   * @returns True if `allowUntrustedScripts` is set in config
+   */
+  getAllowUntrustedScripts() {
+    return this.config.allowUntrustedScripts ?? false;
+  }
+  /**
+   * Get the `allowed-tools` list for a skill.
+   *
+   * Returns the `allowedTools` array from the skill's frontmatter metadata,
+   * enabling agents to filter their tool set based on what the skill expects.
+   *
+   * @param name - The skill name
+   * @returns Array of allowed tool names, or undefined if skill not found or field not set
+   *
+   * @example
+   * ```ts
+   * const allowed = registry.getAllowedTools('code-review');
+   * if (allowed) {
+   *   const filteredTools = allTools.filter(t => allowed.includes(t.name));
+   * }
+   * ```
+   */
+  getAllowedTools(name) {
+    const skill = this.skills.get(name);
+    return skill?.metadata.allowedTools;
+  }
+  // ─── Prompt Generation ─────────────────────────────────────────────────
+  /**
+   * Generate an `<available_skills>` XML block for system prompt injection.
+   *
+   * Returns an empty string when:
+   * - `config.enabled` is `false` (default) — agents operate with unmodified prompts
+   * - No skills match the filter criteria
+   *
+   * The output composes naturally with `toolRegistry.generatePrompt()` —
+   * simply concatenate both into the system prompt.
+   *
+   * @param options - Optional filtering (subset of skill names)
+   * @returns XML string or empty string
+   *
+   * @example
+   * ```ts
+   * // All skills
+   * const xml = registry.generatePrompt();
+   *
+   * // Subset for a focused agent
+   * const xml = registry.generatePrompt({ skills: ['code-review', 'testing'] });
+   *
+   * // Compose with tool prompt
+   * const systemPrompt = [
+   *   toolRegistry.generatePrompt(),
+   *   skillRegistry.generatePrompt(),
+   * ].filter(Boolean).join('\n\n');
+   * ```
+   */
+  generatePrompt(options) {
+    if (!this.config.enabled) {
+      logger7.debug("Skill prompt generation skipped (disabled)", {
+        enabled: this.config.enabled ?? false
+      });
+      return "";
+    }
+    let skills = this.getAll();
+    if (options?.skills && options.skills.length > 0) {
+      const requested = new Set(options.skills);
+      skills = skills.filter((s) => requested.has(s.metadata.name));
+    }
+    if (this.config.maxDiscoveredSkills !== void 0 && this.config.maxDiscoveredSkills >= 0) {
+      skills = skills.slice(0, this.config.maxDiscoveredSkills);
+    }
+    if (skills.length === 0) {
+      logger7.debug("Skill prompt generation produced empty result", {
+        totalDiscovered: this.size(),
+        filterApplied: !!(options?.skills && options.skills.length > 0),
+        maxCap: this.config.maxDiscoveredSkills
+      });
+      return "";
+    }
+    const skillEntries = skills.map((skill) => {
+      const lines = [
+        "  <skill>",
+        `    <name>${escapeXml(skill.metadata.name)}</name>`,
+        `    <description>${escapeXml(skill.metadata.description)}</description>`,
+        `    <location>${escapeXml(skill.skillPath)}</location>`,
+        "  </skill>"
+      ];
+      return lines.join("\n");
+    });
+    const xml = `<available_skills>
+${skillEntries.join("\n")}
+</available_skills>`;
+    const estimatedTokens = Math.ceil(xml.length / 4);
+    logger7.info("Skill prompt generated", {
+      skillCount: skills.length,
+      totalDiscovered: this.size(),
+      filterApplied: !!(options?.skills && options.skills.length > 0),
+      maxCap: this.config.maxDiscoveredSkills,
+      estimatedTokens,
+      xmlLength: xml.length
+    });
+    return xml;
+  }
+  // ─── Event System ──────────────────────────────────────────────────────
+  /**
+   * Register an event handler.
+   *
+   * @param event - The event to listen for
+   * @param handler - The handler function
+   *
+   * @example
+   * ```ts
+   * registry.on(SkillRegistryEvent.SKILL_DISCOVERED, (skill) => {
+   *   console.log('Found skill:', skill.metadata.name);
+   * });
+   * ```
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unregister an event handler.
+   *
+   * @param event - The event to stop listening for
+   * @param handler - The handler function to remove
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event to all registered handlers.
+   *
+   * @param event - The event to emit
+   * @param data - The event data
+   * @private
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          logger7.error("Skill event handler error", {
+            event,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+          });
+        }
+      });
+    }
+  }
+  /**
+   * Emit an event (public API for activation tools).
+   *
+   * Used by skill activation tools to emit `skill:activated` and
+   * `skill:resource-loaded` events through the registry's event system.
+   *
+   * @param event - The event to emit
+   * @param data - The event data
+   */
+  emitEvent(event, data) {
+    this.emit(event, data);
+  }
+  // ─── Tool Integration ────────────────────────────────────────────────
+  /**
+   * Create activation tools pre-wired to this registry instance.
+   *
+   * Returns `activate-skill` and `read-skill-resource` tools that
+   * agents can use to load skill instructions and resources on demand.
+   *
+   * @returns Array of [activate-skill, read-skill-resource] tools
+   *
+   * @example
+   * ```ts
+   * const agent = createReActAgent({
+   *   model: llm,
+   *   tools: [
+   *     ...toolRegistry.toLangChainTools(),
+   *     ...skillRegistry.toActivationTools(),
+   *   ],
+   * });
+   * ```
+   */
+  toActivationTools() {
+    return createSkillActivationTools(this);
+  }
+};
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
 export {
   AgentError,
   AlertManager,
@@ -5325,6 +6161,8 @@ export {
   MissingDescriptionError,
   Profiler,
   RegistryEvent,
+  SkillRegistry,
+  SkillRegistryEvent,
   TimeoutError,
   ToolBuilder,
   ToolCategory,
@@ -5334,6 +6172,7 @@ export {
   ToolNameSchema,
   ToolRegistry,
   ToolRelationsSchema,
+  TrustPolicyReason,
   batch,
   broadcast,
   cache,
@@ -5347,6 +6186,7 @@ export {
   composeWithOptions,
   conditional,
   configureLangSmith,
+  createActivateSkillTool,
   createAlertManager,
   createApprovalRequiredInterrupt,
   createAuditLogger,
@@ -5375,11 +6215,13 @@ export {
   createParallelWorkflow,
   createProfiler,
   createProgressTracker,
+  createReadSkillResourceTool,
   createSSEFormatter,
   createSequentialWorkflow,
   createSharedCache,
   createSharedConcurrencyController,
   createSharedRateLimiter,
+  createSkillActivationTools,
   createSqliteCheckpointer,
   createStateAnnotation,
   createSubgraph,
@@ -5390,6 +6232,8 @@ export {
   createToolUnsafe,
   createWebSocketHandler,
   development,
+  evaluateTrustPolicy,
+  expandHome,
   filter,
   formatAgentResumedEvent,
   formatAgentWaitingEvent,
@@ -5409,20 +6253,26 @@ export {
   isCustomInterrupt,
   isHumanRequestInterrupt,
   isMemoryCheckpointer,
+  isScriptResource,
   isTracingEnabled,
   loadPrompt,
   map,
   merge,
   mergeState,
+  normalizeRootConfig,
   parallel,
   parseSSEEvent,
+  parseSkillContent,
   presets,
   production,
   reduce,
   renderTemplate,
+  resolveResourcePath,
   retry,
   safeValidateSchemaDescriptions,
   sanitizeValue,
+  scanAllSkillRoots,
+  scanSkillRoot,
   sendMessage,
   sequential,
   sequentialBuilder,
@@ -5434,6 +6284,9 @@ export {
   toLangChainTools,
   toolBuilder,
   validateSchemaDescriptions,
+  validateSkillDescription,
+  validateSkillName,
+  validateSkillNameMatchesDir,
   validateState,
   validateTool,
   validateToolMetadata,