opencode-hive 1.0.4 → 1.0.5

package/README.md

@@ -222,12 +222,23 @@ Use `autoLoadSkills` to automatically inject skills into an agent's system promp
 }
 ```
 
+**Supported skill sources:**
+
+`autoLoadSkills` accepts both Hive builtin skill IDs and file-based skill IDs. Resolution order:
+
+1. **Hive builtin** — Skills bundled with opencode-hive (always win if ID matches)
+2. **Project OpenCode** — `<project>/.opencode/skills/<id>/SKILL.md`
+3. **Global OpenCode** — `~/.config/opencode/skills/<id>/SKILL.md`
+4. **Project Claude** — `<project>/.claude/skills/<id>/SKILL.md`
+5. **Global Claude** — `~/.claude/skills/<id>/SKILL.md`
+
+Skill IDs must be safe directory names (no `/`, `\`, `..`, or `.`). Missing or invalid skills emit a warning and are skipped—startup continues without failure.
+
 **How `skills` and `autoLoadSkills` interact:**
 
 - `skills` controls what appears in `hive_skill()` — the agent can manually load these on demand
 - `autoLoadSkills` injects skills unconditionally at session start — no manual loading needed
 - These are **independent**: a skill can be auto-loaded but not appear in `hive_skill()`, or vice versa
-- Both only support Hive's built-in skills (not OpenCode base skills from the `skill()` tool)
 - User `autoLoadSkills` are **merged** with defaults (use global `disableSkills` to remove defaults)
 
 **Default auto-load skills by agent:**

package/dist/index.js

@@ -14,6 +14,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/index.ts
 import * as path7 from "path";
 import * as fs9 from "fs";
+import * as os from "os";
 
 // ../../node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -14140,6 +14141,107 @@ function getFilteredSkills(disabledSkills = [], agentSkills) {
   return filtered;
 }
 
+// src/skills/file-loader.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function validateSkillId(skillId) {
+  if (!skillId || skillId.trim() === "") {
+    return "Skill ID cannot be empty";
+  }
+  if (skillId.includes("/")) {
+    return `Invalid skill ID "${skillId}": contains path traversal character "/"`;
+  }
+  if (skillId.includes("\\")) {
+    return `Invalid skill ID "${skillId}": contains path traversal character "\\"`;
+  }
+  if (skillId.includes("..")) {
+    return `Invalid skill ID "${skillId}": contains path traversal sequence ".."`;
+  }
+  if (skillId === "." || skillId.includes(".")) {
+    return `Invalid skill ID "${skillId}": contains path traversal character "."`;
+  }
+  return;
+}
+function stripQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match)
+    return null;
+  const frontmatter = match[1];
+  const body = match[2];
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  if (!nameMatch || !descMatch)
+    return null;
+  return {
+    name: stripQuotes(nameMatch[1]),
+    description: stripQuotes(descMatch[1]),
+    body
+  };
+}
+function getSearchPaths(skillId, projectRoot, homeDir) {
+  return [
+    path.join(projectRoot, ".opencode", "skills", skillId, "SKILL.md"),
+    path.join(homeDir, ".config", "opencode", "skills", skillId, "SKILL.md"),
+    path.join(projectRoot, ".claude", "skills", skillId, "SKILL.md"),
+    path.join(homeDir, ".claude", "skills", skillId, "SKILL.md")
+  ];
+}
+async function tryReadFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return content;
+  } catch {
+    return null;
+  }
+}
+async function loadFileSkill(skillId, projectRoot, homeDir) {
+  const validationError = validateSkillId(skillId);
+  if (validationError) {
+    return { found: false, error: validationError };
+  }
+  const searchPaths = getSearchPaths(skillId, projectRoot, homeDir);
+  for (const skillPath of searchPaths) {
+    const content = await tryReadFile(skillPath);
+    if (content === null) {
+      continue;
+    }
+    const parsed = parseFrontmatter(content);
+    if (!parsed) {
+      return {
+        found: false,
+        error: `Invalid frontmatter in skill file: ${skillPath}. Expected YAML frontmatter with "name" and "description" fields.`
+      };
+    }
+    if (parsed.name !== skillId) {
+      return {
+        found: false,
+        error: `Skill name mismatch in ${skillPath}: frontmatter name "${parsed.name}" does not match skill ID "${skillId}"`
+      };
+    }
+    const skill = {
+      name: parsed.name,
+      description: parsed.description,
+      template: parsed.body
+    };
+    return {
+      found: true,
+      skill,
+      source: skillPath
+    };
+  }
+  return {
+    found: false,
+    error: `Skill "${skillId}" not found in any of the search paths`
+  };
+}
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Hive (Hybrid)
 
@@ -14875,10 +14977,10 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path from "path";
-import * as fs from "fs";
 import * as path2 from "path";
 import * as fs2 from "fs";
+import * as path22 from "path";
+import * as fs22 from "fs";
 import * as fs3 from "fs";
 import * as fs4 from "fs";
 import * as fs5 from "fs";
@@ -15784,82 +15886,85 @@ var STATUS_FILE = "status.json";
 var REPORT_FILE = "report.md";
 var APPROVED_FILE = "APPROVED";
 var JOURNAL_FILE = "journal.md";
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
 function getHivePath(projectRoot) {
-  return path.join(projectRoot, HIVE_DIR);
+  return path2.join(projectRoot, HIVE_DIR);
 }
 function getJournalPath(projectRoot) {
-  return path.join(getHivePath(projectRoot), JOURNAL_FILE);
+  return path2.join(getHivePath(projectRoot), JOURNAL_FILE);
 }
 function getFeaturesPath(projectRoot) {
-  return path.join(getHivePath(projectRoot), FEATURES_DIR);
+  return path2.join(getHivePath(projectRoot), FEATURES_DIR);
 }
 function getFeaturePath(projectRoot, featureName) {
-  return path.join(getFeaturesPath(projectRoot), featureName);
+  return path2.join(getFeaturesPath(projectRoot), featureName);
 }
 function getPlanPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
+  return path2.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
 }
 function getCommentsPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
+  return path2.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
 }
 function getFeatureJsonPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
+  return path2.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
 }
 function getContextPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
+  return path2.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
 }
 function getTasksPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
+  return path2.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
 }
 function getTaskPath(projectRoot, featureName, taskFolder) {
-  return path.join(getTasksPath(projectRoot, featureName), taskFolder);
+  return path2.join(getTasksPath(projectRoot, featureName), taskFolder);
 }
 function getTaskStatusPath(projectRoot, featureName, taskFolder) {
-  return path.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
+  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
 }
 function getTaskReportPath(projectRoot, featureName, taskFolder) {
-  return path.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
+  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
 }
 function getTaskSpecPath(projectRoot, featureName, taskFolder) {
-  return path.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
+  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
 }
 function getApprovedPath(projectRoot, featureName) {
-  return path.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
+  return path2.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
 }
 var SUBTASKS_DIR = "subtasks";
 var SPEC_FILE = "spec.md";
 function getSubtasksPath(projectRoot, featureName, taskFolder) {
-  return path.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
+  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
 }
 function getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
+  return path2.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
 }
 function getSubtaskStatusPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
+  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
 }
 function getSubtaskSpecPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
+  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
 }
 function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
+  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs.existsSync(filePath);
+  return fs2.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs.existsSync(filePath))
+  if (!fs2.existsSync(filePath))
     return null;
-  const content = fs.readFileSync(filePath, "utf-8");
+  const content = fs2.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
-  ensureDir(path.dirname(filePath));
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  ensureDir(path2.dirname(filePath));
+  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -15871,7 +15976,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs.statSync(lockPath);
+    const stat2 = fs2.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -15889,12 +15994,12 @@ function acquireLockSync(filePath, options = {}) {
   });
   while (true) {
     try {
-      const fd = fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
-      fs.writeSync(fd, lockContent);
-      fs.closeSync(fd);
+      const fd = fs2.openSync(lockPath, fs2.constants.O_CREAT | fs2.constants.O_EXCL | fs2.constants.O_WRONLY);
+      fs2.writeSync(fd, lockContent);
+      fs2.closeSync(fd);
       return () => {
         try {
-          fs.unlinkSync(lockPath);
+          fs2.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -15904,7 +16009,7 @@ function acquireLockSync(filePath, options = {}) {
       }
       if (isLockStale(lockPath, opts.staleLockTTL)) {
         try {
-          fs.unlinkSync(lockPath);
+          fs2.unlinkSync(lockPath);
           continue;
         } catch {}
       }
@@ -15917,14 +16022,14 @@ function acquireLockSync(filePath, options = {}) {
   }
 }
 function writeAtomic(filePath, content) {
-  ensureDir(path.dirname(filePath));
+  ensureDir(path2.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs.writeFileSync(tempPath, content);
-    fs.renameSync(tempPath, filePath);
+    fs2.writeFileSync(tempPath, content);
+    fs2.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs.unlinkSync(tempPath);
+      fs2.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -15967,13 +16072,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs.existsSync(filePath))
+  if (!fs2.existsSync(filePath))
     return null;
-  return fs.readFileSync(filePath, "utf-8");
+  return fs2.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
-  ensureDir(path.dirname(filePath));
-  fs.writeFileSync(filePath, content);
+  ensureDir(path2.dirname(filePath));
+  fs2.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -15983,7 +16088,8 @@ function detectContext(cwd) {
     isWorktree: false,
     mainProjectRoot: null
   };
-  const worktreeMatch = cwd.match(/(.+)\/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
+  const normalizedCwd = normalizePath(cwd);
+  const worktreeMatch = normalizedCwd.match(/(.+)\/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
   if (worktreeMatch) {
     result.mainProjectRoot = worktreeMatch[1];
     result.feature = worktreeMatch[2];
@@ -15992,18 +16098,19 @@ function detectContext(cwd) {
     result.projectRoot = worktreeMatch[1];
     return result;
   }
-  const gitPath = path2.join(cwd, ".git");
-  if (fs2.existsSync(gitPath)) {
-    const stat2 = fs2.statSync(gitPath);
+  const gitPath = path22.join(cwd, ".git");
+  if (fs22.existsSync(gitPath)) {
+    const stat2 = fs22.statSync(gitPath);
     if (stat2.isFile()) {
-      const gitContent = fs2.readFileSync(gitPath, "utf-8").trim();
+      const gitContent = fs22.readFileSync(gitPath, "utf-8").trim();
       const gitdirMatch = gitContent.match(/gitdir:\s*(.+)/);
       if (gitdirMatch) {
         const gitdir = gitdirMatch[1];
-        const worktreePathMatch = gitdir.match(/(.+)\/\.git\/worktrees\/(.+)/);
+        const normalizedGitdir = normalizePath(gitdir);
+        const worktreePathMatch = normalizedGitdir.match(/(.+)\/\.git\/worktrees\/(.+)/);
         if (worktreePathMatch) {
           const mainRepo = worktreePathMatch[1];
-          const cwdWorktreeMatch = cwd.match(/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
+          const cwdWorktreeMatch = normalizedCwd.match(/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
           if (cwdWorktreeMatch) {
             result.mainProjectRoot = mainRepo;
             result.feature = cwdWorktreeMatch[1];
@@ -16020,9 +16127,9 @@ function detectContext(cwd) {
 }
 function listFeatures(projectRoot) {
   const featuresPath = getFeaturesPath(projectRoot);
-  if (!fs2.existsSync(featuresPath))
+  if (!fs22.existsSync(featuresPath))
     return [];
-  return fs2.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  return fs22.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
 }
 var JOURNAL_TEMPLATE = `# Hive Journal
 
@@ -21682,7 +21789,13 @@ function isValidPromptFilePath(filePath, workspaceRoot) {
   try {
     const normalizedFilePath = path5.resolve(filePath);
     const normalizedWorkspace = path5.resolve(workspaceRoot);
-    if (!normalizedFilePath.startsWith(normalizedWorkspace + path5.sep) && normalizedFilePath !== normalizedWorkspace) {
+    let normalizedFilePathForCompare = normalizePath(normalizedFilePath);
+    let normalizedWorkspaceForCompare = normalizePath(normalizedWorkspace);
+    if (process.platform === "win32") {
+      normalizedFilePathForCompare = normalizedFilePathForCompare.toLowerCase();
+      normalizedWorkspaceForCompare = normalizedWorkspaceForCompare.toLowerCase();
+    }
+    if (!normalizedFilePathForCompare.startsWith(normalizedWorkspaceForCompare + "/") && normalizedFilePathForCompare !== normalizedWorkspaceForCompare) {
       return false;
     }
     return true;
@@ -23103,20 +23216,26 @@ function formatSkillsXml(skills) {
 ${skillsXml}
 </available_skills>`;
 }
-function buildAutoLoadedSkillsContent(agentName, configService) {
+async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
   const agentConfig = configService.getAgentConfig(agentName);
   const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
   if (autoLoadSkills.length === 0) {
     return "";
   }
+  const homeDir = process.env.HOME || os.homedir();
   const skillTemplates = [];
   for (const skillId of autoLoadSkills) {
-    const skill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
-    if (!skill) {
-      console.warn(`[hive] Unknown skill id "${skillId}" for agent "${agentName}"`);
+    const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
+    if (builtinSkill) {
+      skillTemplates.push(builtinSkill.template);
+      continue;
+    }
+    const fileResult = await loadFileSkill(skillId, projectRoot, homeDir);
+    if (fileResult.found && fileResult.skill) {
+      skillTemplates.push(fileResult.skill.template);
       continue;
     }
-    skillTemplates.push(skill.template);
+    console.warn(`[hive] Unknown skill id "${skillId}" for agent "${agentName}"`);
   }
   if (skillTemplates.length === 0) {
     return "";
@@ -23705,7 +23824,7 @@ ${priorTasksFormatted}
           });
           const hiveDir = path7.join(directory, ".hive");
           const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-          const relativePromptPath = path7.relative(directory, workerPromptPath);
+          const relativePromptPath = normalizePath(path7.relative(directory, workerPromptPath));
           const PREVIEW_MAX_LENGTH = 200;
           const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
           const hiveBackgroundInstructions = `## Delegation Required
@@ -24262,7 +24381,7 @@ Make the requested changes, then call hive_request_review again.`;
     config: async (opencodeConfig) => {
       configService.init();
       const hiveUserConfig = configService.getAgentConfig("hive-master");
-      const hiveAutoLoadedSkills = buildAutoLoadedSkillsContent("hive-master", configService);
+      const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive-master", configService, directory);
       const hiveConfig = {
         model: hiveUserConfig.model,
         temperature: hiveUserConfig.temperature ?? 0.5,
@@ -24279,7 +24398,7 @@ Make the requested changes, then call hive_request_review again.`;
         }
       };
       const architectUserConfig = configService.getAgentConfig("architect-planner");
-      const architectAutoLoadedSkills = buildAutoLoadedSkillsContent("architect-planner", configService);
+      const architectAutoLoadedSkills = await buildAutoLoadedSkillsContent("architect-planner", configService, directory);
       const architectConfig = {
         model: architectUserConfig.model,
         temperature: architectUserConfig.temperature ?? 0.7,
@@ -24299,7 +24418,7 @@ Make the requested changes, then call hive_request_review again.`;
         }
       };
       const swarmUserConfig = configService.getAgentConfig("swarm-orchestrator");
-      const swarmAutoLoadedSkills = buildAutoLoadedSkillsContent("swarm-orchestrator", configService);
+      const swarmAutoLoadedSkills = await buildAutoLoadedSkillsContent("swarm-orchestrator", configService, directory);
       const swarmConfig = {
         model: swarmUserConfig.model,
         temperature: swarmUserConfig.temperature ?? 0.5,
@@ -24316,7 +24435,7 @@ Make the requested changes, then call hive_request_review again.`;
         }
       };
       const scoutUserConfig = configService.getAgentConfig("scout-researcher");
-      const scoutAutoLoadedSkills = buildAutoLoadedSkillsContent("scout-researcher", configService);
+      const scoutAutoLoadedSkills = await buildAutoLoadedSkillsContent("scout-researcher", configService, directory);
       const scoutConfig = {
         model: scoutUserConfig.model,
         temperature: scoutUserConfig.temperature ?? 0.5,
@@ -24330,7 +24449,7 @@ Make the requested changes, then call hive_request_review again.`;
         }
       };
       const foragerUserConfig = configService.getAgentConfig("forager-worker");
-      const foragerAutoLoadedSkills = buildAutoLoadedSkillsContent("forager-worker", configService);
+      const foragerAutoLoadedSkills = await buildAutoLoadedSkillsContent("forager-worker", configService, directory);
       const foragerConfig = {
         model: foragerUserConfig.model,
         temperature: foragerUserConfig.temperature ?? 0.3,
@@ -24342,7 +24461,7 @@ Make the requested changes, then call hive_request_review again.`;
         }
       };
       const hygienicUserConfig = configService.getAgentConfig("hygienic-reviewer");
-      const hygienicAutoLoadedSkills = buildAutoLoadedSkillsContent("hygienic-reviewer", configService);
+      const hygienicAutoLoadedSkills = await buildAutoLoadedSkillsContent("hygienic-reviewer", configService, directory);
       const hygienicConfig = {
         model: hygienicUserConfig.model,
         temperature: hygienicUserConfig.temperature ?? 0.3,

package/dist/skills/file-loader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * File-based Skill Loader
+ *
+ * Resolves and loads skill files from OpenCode and Claude-compatible paths.
+ * Implements strict skill ID validation and deterministic search order.
+ */
+import type { SkillLoadResult } from './types.js';
+/**
+ * Load a skill from file-based locations.
+ *
+ * Searches for skill files in the following order:
+ * 1. Project OpenCode: `<projectRoot>/.opencode/skills/<skillId>/SKILL.md`
+ * 2. Global OpenCode: `~/.config/opencode/skills/<skillId>/SKILL.md`
+ * 3. Project Claude-compatible: `<projectRoot>/.claude/skills/<skillId>/SKILL.md`
+ * 4. Global Claude-compatible: `~/.claude/skills/<skillId>/SKILL.md`
+ *
+ * @param skillId - The skill ID to load
+ * @param projectRoot - The project root directory
+ * @param homeDir - The user's home directory
+ * @returns The skill load result
+ */
+export declare function loadFileSkill(skillId: string, projectRoot: string, homeDir: string): Promise<SkillLoadResult>;

package/dist/skills/index.d.ts

@@ -5,3 +5,4 @@
  */
 export type { SkillDefinition, SkillLoadResult } from './types.js';
 export { BUILTIN_SKILLS, loadBuiltinSkill, getBuiltinSkills, getFilteredSkills, getBuiltinSkillsXml, type BuiltinSkillName } from './builtin.js';
+export { loadFileSkill } from './file-loader.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",