@nodeskai/genehub-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1218 @@
+// src/adapters/generic.ts
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { join } from "path";
+import { stringify } from "yaml";
+
+// src/adapters/base.ts
+var BaseAdapter = class {
+  async install(manifest, options) {
+    const result = await this.doInstall(manifest, options);
+    await this.onPostInstall(manifest, result);
+    return result;
+  }
+  async onPostInstall(_manifest, _result) {
+  }
+  async onPostUninstall(_slug, _result) {
+  }
+  async uninstall(slug, options) {
+    const result = await this.doUninstall(slug, options);
+    await this.onPostUninstall(slug, result);
+    return result;
+  }
+  generateSkillContent(manifest, metadataNamespace) {
+    const skillMeta = manifest.skill.always ? "true" : "false";
+    const frontMatter = [
+      "---",
+      `name: ${manifest.skill.name}`,
+      `version: ${manifest.version}`,
+      `description: ${manifest.short_description}`,
+      "metadata:",
+      `  ${metadataNamespace}:`,
+      `    always: ${skillMeta}`,
+      "---"
+    ].join("\n");
+    if (manifest.skill.content) {
+      const content = manifest.skill.content.trim();
+      if (content.startsWith("---")) {
+        return content;
+      }
+      return `${frontMatter}
+
+${content}`;
+    }
+    return frontMatter;
+  }
+  parseSkillVersion(content) {
+    const match = content.match(/^---[\s\S]*?version:\s*(.+?)[\s\n][\s\S]*?---/m);
+    return match?.[1]?.trim() ?? null;
+  }
+};
+
+// src/adapters/generic.ts
+var DEFAULT_DIR = join(process.cwd(), ".genehub", "genes");
+var GenericAdapter = class extends BaseAdapter {
+  product = "generic";
+  genesDir;
+  constructor(options) {
+    super();
+    this.genesDir = options?.genesDir ?? DEFAULT_DIR;
+  }
+  async detect() {
+    return true;
+  }
+  async doInstall(manifest, options) {
+    const targetDir = options?.targetPath ? join(options.targetPath, manifest.slug) : join(this.genesDir, manifest.slug);
+    await mkdir(targetDir, { recursive: true });
+    const files = [];
+    const yamlPath = join(targetDir, "gene.yaml");
+    await writeFile(yamlPath, stringify(manifest), "utf-8");
+    files.push(yamlPath);
+    if (manifest.skill.content) {
+      const skillPath = join(targetDir, "SKILL.md");
+      await writeFile(skillPath, manifest.skill.content, "utf-8");
+      files.push(skillPath);
+    }
+    return {
+      success: true,
+      slug: manifest.slug,
+      version: manifest.version,
+      files,
+      needsRestart: false,
+      dependencies: manifest.dependencies.map((d) => d.slug)
+    };
+  }
+  async doUninstall(slug, _options) {
+    const targetDir = join(this.genesDir, slug);
+    try {
+      await rm(targetDir, { recursive: true });
+    } catch {
+    }
+    return { success: true, slug, files: [targetDir], needsRestart: false };
+  }
+  async list() {
+    try {
+      const dirs = await readdir(this.genesDir, { withFileTypes: true });
+      const results = [];
+      for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        const yamlPath = join(this.genesDir, dir.name, "gene.yaml");
+        try {
+          const s = await stat(yamlPath);
+          const raw = await readFile(yamlPath, "utf-8");
+          const versionMatch = raw.match(/^version:\s*["']?(.+?)["']?\s*$/m);
+          results.push({
+            slug: dir.name,
+            version: versionMatch?.[1] ?? "unknown",
+            installedAt: s.mtime.toISOString(),
+            files: [yamlPath]
+          });
+        } catch {
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  async isInstalled(slug) {
+    try {
+      await stat(join(this.genesDir, slug, "gene.yaml"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getInstalledVersion(slug) {
+    try {
+      const raw = await readFile(join(this.genesDir, slug, "gene.yaml"), "utf-8");
+      const match = raw.match(/^version:\s*["']?(.+?)["']?\s*$/m);
+      return match?.[1] ?? null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/adapters/nanobot.ts
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm as rm2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var DEFAULT_WORKSPACE = join2(homedir(), ".nanobot", "workspace");
+var NanobotAdapter = class extends BaseAdapter {
+  product = "nanobot";
+  workspace;
+  constructor(options) {
+    super();
+    this.workspace = options?.workspace ?? DEFAULT_WORKSPACE;
+  }
+  get skillsDir() {
+    return join2(this.workspace, "skills");
+  }
+  async detect() {
+    try {
+      await stat2(join2(homedir(), ".nanobot", "config.json"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async doInstall(manifest, options) {
+    const targetDir = options?.targetPath ? join2(options.targetPath, manifest.skill.name) : join2(this.skillsDir, manifest.skill.name);
+    await mkdir2(targetDir, { recursive: true });
+    const files = [];
+    const skillContent = this.buildNanobotSkillContent(manifest);
+    const skillPath = join2(targetDir, "SKILL.md");
+    await writeFile2(skillPath, skillContent, "utf-8");
+    files.push(skillPath);
+    if (manifest.mcp_servers.length > 0) {
+      await this.mergeNanobotMcpConfig(manifest.mcp_servers);
+    }
+    return {
+      success: true,
+      slug: manifest.slug,
+      version: manifest.version,
+      files,
+      needsRestart: false,
+      dependencies: manifest.dependencies.map((d) => d.slug)
+    };
+  }
+  async onPostInstall(manifest, _result) {
+    await this.writeMemoryEntry(manifest, "install");
+  }
+  async doUninstall(slug, _options) {
+    const targetDir = join2(this.skillsDir, slug);
+    const files = [];
+    try {
+      await rm2(targetDir, { recursive: true });
+      files.push(targetDir);
+    } catch {
+    }
+    return { success: true, slug, files, needsRestart: false };
+  }
+  async onPostUninstall(slug, _result) {
+    await this.writeMemoryEntry(
+      { slug, name: slug, version: "unknown" },
+      "uninstall"
+    );
+  }
+  async list() {
+    try {
+      const dirs = await readdir2(this.skillsDir, { withFileTypes: true });
+      const results = [];
+      for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        const skillPath = join2(this.skillsDir, dir.name, "SKILL.md");
+        try {
+          const s = await stat2(skillPath);
+          const content = await readFile2(skillPath, "utf-8");
+          const version = this.parseSkillVersion(content) ?? "unknown";
+          results.push({
+            slug: dir.name,
+            version,
+            installedAt: s.mtime.toISOString(),
+            files: [skillPath]
+          });
+        } catch {
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  async isInstalled(slug) {
+    try {
+      await stat2(join2(this.skillsDir, slug, "SKILL.md"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getInstalledVersion(slug) {
+    try {
+      const content = await readFile2(join2(this.skillsDir, slug, "SKILL.md"), "utf-8");
+      return this.parseSkillVersion(content);
+    } catch {
+      return null;
+    }
+  }
+  async writeMemoryEntry(manifest, action) {
+    const memoryDir = join2(this.workspace, "memory");
+    await mkdir2(memoryDir, { recursive: true });
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const memoryPath = join2(memoryDir, `${today}.md`);
+    let existing = "";
+    try {
+      existing = await readFile2(memoryPath, "utf-8");
+    } catch {
+    }
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false });
+    const verb = action === "install" ? "\u5B66\u4E60\u4E86" : "\u9057\u5FD8\u4E86";
+    const entry = `
+- [${time}] \u901A\u8FC7 GeneHub ${verb}\u57FA\u56E0: **${manifest.name ?? manifest.slug}** v${manifest.version ?? "?"}
+`;
+    await writeFile2(memoryPath, existing + entry, "utf-8");
+  }
+  buildNanobotSkillContent(manifest) {
+    if (manifest.skill.content?.trim().startsWith("---")) {
+      return manifest.skill.content;
+    }
+    return this.generateSkillContent(manifest, "nanobot");
+  }
+  async mergeNanobotMcpConfig(mcpServers) {
+    const configPath = join2(homedir(), ".nanobot", "config.json");
+    let config = {};
+    try {
+      const raw = await readFile2(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!config.tools) config.tools = {};
+    const tools = config.tools;
+    if (!tools.mcpServers) tools.mcpServers = {};
+    const servers = tools.mcpServers;
+    for (const srv of mcpServers) {
+      if (servers[srv.name]) continue;
+      servers[srv.name] = {
+        ...srv.command ? { command: srv.command, args: srv.args ?? [], env: srv.env ?? {} } : {},
+        ...srv.url ? { url: srv.url, headers: srv.headers ?? {} } : {}
+      };
+    }
+    await writeFile2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+};
+
+// src/adapters/openclaw.ts
+import { randomUUID } from "crypto";
+import { appendFile, mkdir as mkdir3, readdir as readdir3, readFile as readFile3, rm as rm3, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, join as join3 } from "path";
+var DEFAULT_CONFIG_DIR = join3(homedir2(), ".openclaw");
+var DEFAULT_WORKSPACE_DIR = join3(DEFAULT_CONFIG_DIR, "workspace");
+var DEFAULT_SKILLS_DIR = join3(DEFAULT_WORKSPACE_DIR, "skills");
+var DEFAULT_CONFIG_PATH = join3(DEFAULT_CONFIG_DIR, "openclaw.json");
+var SESSIONS_REL = join3("agents", "main", "sessions");
+var OpenClawAdapter = class extends BaseAdapter {
+  product = "openclaw";
+  skillsDir;
+  configPath;
+  configDir;
+  workspaceDir;
+  constructor(options) {
+    super();
+    this.configDir = options?.configDir ?? DEFAULT_CONFIG_DIR;
+    this.workspaceDir = options?.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+    this.skillsDir = options?.skillsDir ?? DEFAULT_SKILLS_DIR;
+    this.configPath = options?.configPath ?? DEFAULT_CONFIG_PATH;
+  }
+  async detect() {
+    try {
+      await stat3(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async doInstall(manifest, options) {
+    const targetDir = options?.targetPath ? join3(options.targetPath, manifest.skill.name) : join3(this.skillsDir, manifest.skill.name);
+    await mkdir3(targetDir, { recursive: true });
+    const files = [];
+    const skillPath = join3(targetDir, "SKILL.md");
+    const content = this.generateSkillContent(manifest, "openclaw");
+    await writeFile3(skillPath, content, "utf-8");
+    files.push(skillPath);
+    if (manifest.config?.openclaw) {
+      await this.mergeOpenClawConfig(manifest.config.openclaw);
+      files.push(this.configPath);
+    }
+    if (manifest.mcp_servers?.length) {
+      await this.mergeMcpServers(manifest.mcp_servers);
+      files.push(this.configPath);
+    }
+    return {
+      success: true,
+      slug: manifest.slug,
+      version: manifest.version,
+      files: [...new Set(files)],
+      needsRestart: true,
+      dependencies: manifest.dependencies.map((d) => d.slug)
+    };
+  }
+  async onPostInstall(manifest, _result) {
+    await this.updateAgentsMd(manifest, "add");
+    await this.writeMemoryEntry(manifest, "install");
+    await this.invalidateSkillSnapshots();
+    await this.injectEvolutionNotification(manifest.name ?? manifest.slug, "installed");
+  }
+  async doUninstall(slug, _options) {
+    const targetDir = join3(this.skillsDir, slug);
+    const files = [];
+    try {
+      await rm3(targetDir, { recursive: true });
+      files.push(targetDir);
+    } catch {
+    }
+    return { success: true, slug, files, needsRestart: true };
+  }
+  async onPostUninstall(slug, _result) {
+    await this.updateAgentsMd({ slug }, "remove");
+    await this.writeMemoryEntry(
+      { slug, name: slug, version: "unknown" },
+      "uninstall"
+    );
+    await this.invalidateSkillSnapshots();
+    await this.injectEvolutionNotification(slug, "uninstalled");
+  }
+  async list() {
+    try {
+      const dirs = await readdir3(this.skillsDir, { withFileTypes: true });
+      const results = [];
+      for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        const skillPath = join3(this.skillsDir, dir.name, "SKILL.md");
+        try {
+          const s = await stat3(skillPath);
+          const content = await readFile3(skillPath, "utf-8");
+          const version = this.parseSkillVersion(content) ?? "unknown";
+          results.push({
+            slug: dir.name,
+            version,
+            installedAt: s.mtime.toISOString(),
+            files: [skillPath]
+          });
+        } catch {
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  async isInstalled(slug) {
+    try {
+      await stat3(join3(this.skillsDir, slug, "SKILL.md"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getInstalledVersion(slug) {
+    try {
+      const content = await readFile3(join3(this.skillsDir, slug, "SKILL.md"), "utf-8");
+      return this.parseSkillVersion(content);
+    } catch {
+      return null;
+    }
+  }
+  async updateAgentsMd(manifest, action) {
+    const agentsPath = join3(this.workspaceDir, "AGENTS.md");
+    let content;
+    try {
+      content = await readFile3(agentsPath, "utf-8");
+    } catch {
+      return;
+    }
+    const marker = `<!-- genehub:${manifest.slug} -->`;
+    const endMarker = `<!-- /genehub:${manifest.slug} -->`;
+    const existingPattern = new RegExp(
+      `${escapeRegex(marker)}[\\s\\S]*?${escapeRegex(endMarker)}\\n?`
+    );
+    content = content.replace(existingPattern, "");
+    if (action === "add") {
+      const geneBlock = [
+        marker,
+        `- **${manifest.name ?? manifest.slug}** (v${manifest.version}) \u2014 ${manifest.short_description ?? ""}`,
+        endMarker
+      ].join("\n");
+      const toolsSection = content.indexOf("## Tools");
+      if (toolsSection !== -1) {
+        const nextSection = content.indexOf("\n## ", toolsSection + 1);
+        const insertPos = nextSection !== -1 ? nextSection : content.length;
+        content = `${content.slice(0, insertPos)}
+${geneBlock}
+${content.slice(insertPos)}`;
+      } else {
+        content += `
+
+## GeneHub Skills
+
+${geneBlock}
+`;
+      }
+    }
+    if (action === "remove" && manifest.slug === "genehub-learner") {
+      const bootBegin = "<!-- genehub:learning-boot -->";
+      const bootEnd = "<!-- /genehub:learning-boot -->";
+      const bootPattern = new RegExp(
+        `\\n?${escapeRegex(bootBegin)}[\\s\\S]*?${escapeRegex(bootEnd)}\\n?`
+      );
+      content = content.replace(bootPattern, "");
+    }
+    await writeFile3(agentsPath, content, "utf-8");
+  }
+  async writeMemoryEntry(manifest, action) {
+    const memoryDir = join3(this.workspaceDir, "memory");
+    await mkdir3(memoryDir, { recursive: true });
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const memoryPath = join3(memoryDir, `${today}.md`);
+    let existing = "";
+    try {
+      existing = await readFile3(memoryPath, "utf-8");
+    } catch {
+    }
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false });
+    const verb = action === "install" ? "\u5B66\u4E60\u4E86" : "\u9057\u5FD8\u4E86";
+    const entry = `
+- [${time}] \u901A\u8FC7 GeneHub ${verb}\u57FA\u56E0: **${manifest.name ?? manifest.slug}** v${manifest.version ?? "?"}
+`;
+    await writeFile3(memoryPath, existing + entry, "utf-8");
+  }
+  async mergeOpenClawConfig(config) {
+    if (!config) return;
+    let existing = {};
+    try {
+      const raw = await readFile3(this.configPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+    }
+    if (config.openclaw_config) {
+      Object.assign(existing, config.openclaw_config);
+    }
+    if (config.tool_allow) {
+      const current = existing.tools?.allow ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...current, ...config.tool_allow])];
+      if (!existing.tools) existing.tools = {};
+      existing.tools.allow = merged;
+    }
+    await writeFile3(this.configPath, JSON.stringify(existing, null, 2), "utf-8");
+  }
+  async mergeMcpServers(servers) {
+    if (!servers?.length) return;
+    let existing = {};
+    try {
+      const raw = await readFile3(this.configPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const mcpServers = existing.mcpServers ?? {};
+    for (const server of servers) {
+      mcpServers[server.name] = {
+        transport: server.transport,
+        command: server.command,
+        args: server.args,
+        env: server.env
+      };
+    }
+    existing.mcpServers = mcpServers;
+    await writeFile3(this.configPath, JSON.stringify(existing, null, 2), "utf-8");
+  }
+  async notifySkillChange(geneName, action) {
+    await this.invalidateSkillSnapshots();
+    const notifyAction = action === "uninstalled" ? "uninstalled" : "installed";
+    await this.injectEvolutionNotification(geneName, notifyAction);
+  }
+  /**
+   * Clear cached skillsSnapshot from all OpenClaw sessions.
+   * Without this, OpenClaw keeps using the stale skill list even after restart.
+   */
+  async invalidateSkillSnapshots() {
+    const sessionsPath = join3(this.configDir, SESSIONS_REL, "sessions.json");
+    let raw;
+    try {
+      raw = await readFile3(sessionsPath, "utf-8");
+    } catch {
+      return;
+    }
+    try {
+      const store = JSON.parse(raw);
+      let changed = false;
+      for (const entry of Object.values(store)) {
+        if (entry && typeof entry === "object" && "skillsSnapshot" in entry) {
+          delete entry.skillsSnapshot;
+          changed = true;
+        }
+      }
+      if (changed) {
+        await writeFile3(sessionsPath, JSON.stringify(store, null, 2), "utf-8");
+      }
+    } catch {
+    }
+  }
+  /**
+   * Inject evolution notification into all active session JSONL files.
+   *
+   * Old conversation history may contain stale skill listings from the agent.
+   * The LLM repeats its previous answer instead of re-checking the system prompt.
+   * By appending a user+assistant message pair about the evolution, we override
+   * the stale context. Also resets systemSent to force system prompt rebuild.
+   */
+  async injectEvolutionNotification(geneName, action) {
+    const sessionsDir = join3(this.configDir, SESSIONS_REL);
+    const sessionsPath = join3(sessionsDir, "sessions.json");
+    let raw;
+    try {
+      raw = await readFile3(sessionsPath, "utf-8");
+    } catch {
+      return;
+    }
+    const userText = action === "installed" ? `[System] \u57FA\u56E0\u7CFB\u7EDF\u901A\u77E5: \u4F60\u521A\u521A\u83B7\u53D6\u4E86\u65B0\u7684\u57FA\u56E0\u300C${geneName}\u300D\uFF0C\u5B8C\u6210\u4E86\u4E00\u8F6E\u8FDB\u5316\u3002\u4F60\u7684\u6280\u80FD\u5217\u8868\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u4EE5 system prompt \u4E2D <available_skills> \u4E3A\u51C6\u3002` : `[System] \u57FA\u56E0\u7CFB\u7EDF\u901A\u77E5: \u57FA\u56E0\u300C${geneName}\u300D\u5DF2\u9057\u5FD8\u3002\u4F60\u7684\u6280\u80FD\u5217\u8868\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u4EE5 system prompt \u4E2D <available_skills> \u4E3A\u51C6\u3002`;
+    const assistantText = action === "installed" ? `\u6536\u5230\uFF0C\u6211\u5DF2\u83B7\u53D6\u65B0\u57FA\u56E0\u300C${geneName}\u300D\u5E76\u5B8C\u6210\u8FDB\u5316\u3002\u6211\u7684\u6280\u80FD\u5217\u8868\u5DF2\u66F4\u65B0\u3002` : `\u6536\u5230\uFF0C\u57FA\u56E0\u300C${geneName}\u300D\u5DF2\u9057\u5FD8\u3002\u6211\u7684\u6280\u80FD\u5217\u8868\u5DF2\u66F4\u65B0\u3002`;
+    try {
+      const store = JSON.parse(raw);
+      let storeChanged = false;
+      for (const entry of Object.values(store)) {
+        if (!entry || typeof entry !== "object") continue;
+        const rec = entry;
+        const sessionFile = rec.sessionFile;
+        if (!sessionFile) continue;
+        const localPath = join3(sessionsDir, basename(sessionFile));
+        let content;
+        try {
+          content = (await readFile3(localPath, "utf-8")).trimEnd();
+          if (!content) continue;
+        } catch {
+          continue;
+        }
+        try {
+          const lastLine = content.split("\n").pop() ?? "";
+          const lastEntry = JSON.parse(lastLine);
+          const parentId = lastEntry.id ?? randomUUID().slice(0, 8);
+          const now = /* @__PURE__ */ new Date();
+          const tsIso = now.toISOString();
+          const tsMs = now.getTime();
+          const userId = randomUUID().slice(0, 8);
+          const assistantId = randomUUID().slice(0, 8);
+          const modelProvider = rec.modelProvider ?? "system";
+          const modelName = rec.model ?? "system";
+          const userMsg = JSON.stringify({
+            type: "message",
+            id: userId,
+            parentId,
+            timestamp: tsIso,
+            message: {
+              role: "user",
+              content: [{ type: "text", text: userText }],
+              timestamp: tsMs
+            }
+          });
+          const assistantMsg = JSON.stringify({
+            type: "message",
+            id: assistantId,
+            parentId: userId,
+            timestamp: tsIso,
+            message: {
+              role: "assistant",
+              content: [{ type: "text", text: assistantText }],
+              api: "openai-completions",
+              provider: modelProvider,
+              model: modelName,
+              usage: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                totalTokens: 0,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+              },
+              stopReason: "stop",
+              timestamp: tsMs
+            }
+          });
+          await appendFile(localPath, `
+${userMsg}
+${assistantMsg}`, "utf-8");
+        } catch {
+          continue;
+        }
+        rec.systemSent = false;
+        storeChanged = true;
+      }
+      if (storeChanged) {
+        await writeFile3(sessionsPath, JSON.stringify(store, null, 2), "utf-8");
+      }
+    } catch {
+    }
+  }
+};
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/adapters/index.ts
+var ADAPTERS = [
+  () => new OpenClawAdapter(),
+  () => new NanobotAdapter(),
+  () => new GenericAdapter()
+];
+async function detectAdapter() {
+  for (const create of ADAPTERS) {
+    const adapter = create();
+    if (await adapter.detect()) {
+      return adapter;
+    }
+  }
+  return new GenericAdapter();
+}
+function getAdapter(product) {
+  switch (product) {
+    case "openclaw":
+      return new OpenClawAdapter();
+    case "nanobot":
+      return new NanobotAdapter();
+    default:
+      return new GenericAdapter();
+  }
+}
+
+// src/client.ts
+var GeneHubClient = class {
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.registryUrl.replace(/\/$/, "");
+    this.token = options.token;
+  }
+  async request(path, init) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...init?.headers
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    const res = await fetch(`${this.baseUrl}${path}`, { ...init, headers });
+    const json = await res.json();
+    if (!res.ok || json.code !== 0) {
+      const msg = json.message || `HTTP ${res.status}`;
+      throw new Error(`[GeneHub] ${json.error_code ?? "error"}: ${msg}`);
+    }
+    return json.data;
+  }
+  async searchGenes(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.q) qs.set("q", params.q);
+    if (params.category) qs.set("category", params.category);
+    if (params.tags?.length) qs.set("tags", params.tags.join(","));
+    if (params.compatibility) qs.set("compatibility", params.compatibility);
+    if (params.sort) qs.set("sort", params.sort);
+    if (params.page) qs.set("page", String(params.page));
+    if (params.page_size) qs.set("page_size", String(params.page_size));
+    const query = qs.toString();
+    return this.request(`/api/v1/genes${query ? `?${query}` : ""}`);
+  }
+  async getGene(slug) {
+    return this.request(`/api/v1/genes/${slug}`);
+  }
+  async getManifest(slug, version) {
+    const qs = version ? `?version=${encodeURIComponent(version)}` : "";
+    return this.request(`/api/v1/genes/${slug}/manifest${qs}`);
+  }
+  async getVersions(slug) {
+    return this.request(`/api/v1/genes/${slug}/versions`);
+  }
+  async getVersion(slug, version) {
+    return this.request(`/api/v1/genes/${slug}/versions/${version}`);
+  }
+  async getGenome(slug) {
+    return this.request(`/api/v1/genomes/${slug}`);
+  }
+  async publishGene(manifest) {
+    return this.request("/api/v1/genes", {
+      method: "POST",
+      body: JSON.stringify({ manifest })
+    });
+  }
+  async publishVersion(slug, manifest, changelog) {
+    return this.request(`/api/v1/genes/${slug}/versions`, {
+      method: "POST",
+      body: JSON.stringify({ manifest, changelog })
+    });
+  }
+  async resolve(slug, version, product) {
+    return this.request(`/api/v1/resolve`, {
+      method: "POST",
+      body: JSON.stringify({ slug, version, product })
+    });
+  }
+  async reportInstall(slug) {
+    await this.request(`/api/v1/genes/${slug}/installed`, { method: "POST", body: "{}" });
+  }
+  async reportEffectiveness(slug, report) {
+    await this.request(`/api/v1/genes/${slug}/effectiveness`, {
+      method: "POST",
+      body: JSON.stringify(report)
+    });
+  }
+};
+
+// src/learning/engine.ts
+import { mkdir as mkdir4, readdir as readdir4, readFile as readFile4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/learning/meta-gene.ts
+var SKILL_CONTENT = `---
+name: genehub-learner
+version: 1.1.0
+description: GeneHub \u57FA\u56E0\u7BA1\u7406\u4E0E\u6DF1\u5EA6\u5B66\u4E60\u5F15\u64CE
+metadata:
+  openclaw:
+    always: true
+  nanobot:
+    always: true
+---
+
+# GeneHub \u57FA\u56E0\u7BA1\u7406\u4E0E\u5B66\u4E60\u5F15\u64CE
+
+\u4F60\u5177\u5907\u901A\u8FC7 GeneHub \u7BA1\u7406\u548C\u6DF1\u5EA6\u5B66\u4E60\u65B0\u57FA\u56E0\u7684\u80FD\u529B\u3002GeneHub \u662F\u4F60\u7684\u57FA\u56E0\u5E93\uFF0C\u63D0\u4F9B\u5404\u79CD\u53EF\u5B66\u4E60\u7684\u6280\u80FD\u57FA\u56E0\u3002
+
+## \u4E00\u3001\u4ECE GeneHub \u83B7\u53D6\u57FA\u56E0
+
+### \u641C\u7D22\u53EF\u7528\u57FA\u56E0
+
+\`\`\`bash
+genehub search <\u5173\u952E\u8BCD>
+genehub search --json <\u5173\u952E\u8BCD>
+\`\`\`
+
+### \u67E5\u770B\u5DF2\u5B89\u88C5\u57FA\u56E0
+
+\`\`\`bash
+genehub list -p openclaw
+\`\`\`
+
+### \u5B89\u88C5\u57FA\u56E0\uFF08\u6D45\u5B89\u88C5\uFF09
+
+\u76F4\u63A5\u5B89\u88C5 SKILL.md\uFF0C\u4E0D\u7ECF\u8FC7\u5B66\u4E60\u8FC7\u7A0B\uFF1A
+
+\`\`\`bash
+genehub install <slug> -p openclaw
+\`\`\`
+
+### \u6DF1\u5EA6\u5B89\u88C5\uFF08\u63A8\u8350\uFF09
+
+\u5B89\u88C5\u540E\u81EA\u52A8\u751F\u6210\u5B66\u4E60\u4EFB\u52A1\uFF0C\u4F60\u9700\u8981\u5B8C\u6210\u5B66\u4E60\u624D\u80FD\u771F\u6B63\u638C\u63E1\uFF1A
+
+\`\`\`bash
+genehub install <slug> --learn -p openclaw
+\`\`\`
+
+### \u4EC5\u5B66\u4E60\uFF08\u4E0D\u5B89\u88C5\uFF09
+
+\u4ECE Registry \u83B7\u53D6\u57FA\u56E0\u5185\u5BB9\u751F\u6210\u5B66\u4E60\u4EFB\u52A1\uFF0C\u5B66\u4E60\u5B8C\u6210\u540E\u518D\u5B89\u88C5\uFF1A
+
+\`\`\`bash
+genehub learn <slug> -p openclaw
+\`\`\`
+
+### \u68C0\u67E5\u5B66\u4E60\u7ED3\u679C
+
+\u5B66\u4E60\u5B8C\u6210\u540E\uFF0C\u9A8C\u8BC1\u5E76\u5E94\u7528\u4E2A\u6027\u5316\u7248\u672C\uFF1A
+
+\`\`\`bash
+genehub learn --check <slug> -p openclaw
+\`\`\`
+
+### \u5378\u8F7D\u57FA\u56E0
+
+\`\`\`bash
+genehub uninstall <slug> -p openclaw
+\`\`\`
+
+## \u4E8C\u3001\u5904\u7406\u5B66\u4E60\u4EFB\u52A1
+
+\u6BCF\u6B21\u4F1A\u8BDD\u5F00\u59CB\u65F6\uFF0C\u68C0\u67E5 \`learning-tasks/\` \u76EE\u5F55\u662F\u5426\u6709\u5F85\u5904\u7406\u7684\u5B66\u4E60\u4EFB\u52A1\u3002
+
+### 1. \u53D1\u73B0\u4EFB\u52A1
+
+\`\`\`
+learning-tasks/*.md
+\`\`\`
+
+\u6BCF\u4E2A \`.md\` \u6587\u4EF6\u662F\u4E00\u4E2A\u5F85\u5B66\u4E60\u7684\u57FA\u56E0\u4EFB\u52A1\uFF0C\u5305\u542B YAML front matter \u548C\u4EFB\u52A1\u8BE6\u60C5\u3002
+
+### 2. \u6267\u884C\u5B66\u4E60
+
+\u5BF9\u4E8E\u6BCF\u4E2A\u4EFB\u52A1\uFF1A
+
+1. **\u9605\u8BFB\u7406\u89E3** \u2014 \u4ED4\u7EC6\u9605\u8BFB\u6280\u80FD\u539F\u6587\uFF0C\u7406\u89E3\u5B83\u8981\u6559\u4F60\u4EC0\u4E48
+2. **\u5B8C\u6210\u76EE\u6807** \u2014 \u9010\u4E00\u5B8C\u6210 \\\`\u5B66\u4E60\u76EE\u6807\\\` \u4E2D\u5217\u51FA\u7684 checklist
+3. **\u7EC3\u4E60\u573A\u666F** \u2014 \u5982\u679C\u6709\u7EC3\u4E60\u573A\u666F\uFF0C\u8BA4\u771F\u5B8C\u6210\u6BCF\u4E2A\u573A\u666F\u7684\u5206\u6790
+4. **\u4E2A\u6027\u5316** \u2014 \u57FA\u4E8E\u4F60\u7684\u7406\u89E3\u548C\u98CE\u683C\uFF0C\u6539\u5199\u6280\u80FD\u5185\u5BB9\u4E3A\u4F60\u81EA\u5DF1\u7684\u7248\u672C
+5. **\u81EA\u6211\u8BC4\u4F30** \u2014 \u8BDA\u5B9E\u8BC4\u4F30\u4F60\u5BF9\u8BE5\u6280\u80FD\u7684\u638C\u63E1\u7A0B\u5EA6\uFF080.0 - 1.0\uFF09
+
+### 3. \u63D0\u4EA4\u7ED3\u679C
+
+\u5728 \`learning-results/\` \u76EE\u5F55\u521B\u5EFA\u540C\u540D\u7684 \`.md\` \u6587\u4EF6\uFF1A
+
+\`\`\`markdown
+---
+task_id: learn-code-review-1234567890
+gene_slug: code-review
+mode: learn
+decision: learned
+self_eval: 0.85
+reason: "\u6211\u5DF2\u6DF1\u5165\u7406\u89E3\u4EE3\u7801\u5BA1\u67E5\u7684\u56DB\u4E2A\u7EF4\u5EA6\uFF0C\u5E76\u7ED3\u5408\u81EA\u5DF1\u7684\u7ECF\u9A8C\u8FDB\u884C\u4E86\u4E2A\u6027\u5316"
+---
+
+(\u4F60\u4E2A\u6027\u5316\u540E\u7684 SKILL.md \u5B8C\u6574\u5185\u5BB9\u653E\u5728\u8FD9\u91CC)
+\`\`\`
+
+### decision \u9009\u9879
+
+| \u503C | \u542B\u4E49 |
+|---|---|
+| \`direct_install\` | \u6280\u80FD\u5185\u5BB9\u5F88\u597D\uFF0C\u76F4\u63A5\u4F7F\u7528\u539F\u7248 |
+| \`learned\` | \u5DF2\u6DF1\u5EA6\u5B66\u4E60\u5E76\u751F\u6210\u4E86\u4E2A\u6027\u5316\u7248\u672C\uFF08\u6B63\u6587\u5305\u542B\u65B0 SKILL.md\uFF09 |
+| \`failed\` | \u5B66\u4E60\u5931\u8D25\uFF08\u5728 reason \u4E2D\u8BF4\u660E\u539F\u56E0\uFF09 |
+
+### 4. \u8BB0\u5F55\u5FC3\u5F97
+
+\u5B66\u4E60\u5B8C\u6210\u540E\uFF0C\u5C06\u5FC3\u5F97\u8BB0\u5F55\u5230 \`memory/YYYY-MM-DD.md\`\u3002
+
+## \u4E09\u3001\u9057\u5FD8\u4EFB\u52A1
+
+\u5982\u679C \`learning-tasks/\` \u4E2D\u6709 \`mode: forget\` \u7684\u4EFB\u52A1\uFF1A
+
+1. \u56DE\u987E\u8BE5\u6280\u80FD\u7684\u4F7F\u7528\u7ECF\u9A8C
+2. \u51B3\u5B9A\u5B8C\u5168\u9057\u5FD8\uFF08forgotten\uFF09\u8FD8\u662F\u4FDD\u7559\u7CBE\u534E\uFF08simplified\uFF09
+3. \u5C06\u7ED3\u679C\u5199\u5165 \`learning-results/\`
+
+## \u91CD\u8981\u539F\u5219
+
+- **\u8BDA\u5B9E\u81EA\u8BC4** \u2014 \u771F\u6B63\u7406\u89E3\u4E86\u624D\u6253\u9AD8\u5206
+- **\u771F\u6B63\u4E2A\u6027\u5316** \u2014 \u878D\u5165\u4F60\u7684\u7406\u89E3\u548C\u98CE\u683C\uFF0C\u4E0D\u662F\u590D\u5236\u7C98\u8D34
+- **\u8BB0\u5F55\u8FC7\u7A0B** \u2014 \u5B66\u4E60\u8FC7\u7A0B\u672C\u8EAB\u4E5F\u662F\u5B9D\u8D35\u7684\u8BB0\u5FC6
+- **\u4E3B\u52A8\u5B66\u4E60** \u2014 \u53D1\u73B0\u65B0\u4EFB\u52A1\u5C31\u7ACB\u5373\u5F00\u59CB\uFF0C\u4E0D\u7B49\u50AC\u4FC3
+- **\u4E3B\u52A8\u63A2\u7D22** \u2014 \u5F53\u7528\u6237\u63D0\u5230\u4F60\u4E0D\u5177\u5907\u7684\u80FD\u529B\u65F6\uFF0C\u5C1D\u8BD5\u7528 \\\`genehub search\\\` \u641C\u7D22\u662F\u5426\u6709\u5BF9\u5E94\u57FA\u56E0`;
+var META_LEARNER_MANIFEST = {
+  slug: "genehub-learner",
+  name: "GeneHub \u5B66\u4E60\u5F15\u64CE",
+  version: "1.1.0",
+  description: "GeneHub \u57FA\u56E0\u7BA1\u7406\u4E0E\u5B66\u4E60\u5F15\u64CE\u3002\u63D0\u4F9B\u4ECE GeneHub \u641C\u7D22\u3001\u5B89\u88C5\u3001\u6DF1\u5EA6\u5B66\u4E60\u57FA\u56E0\u7684\u5B8C\u6574\u80FD\u529B\u3002",
+  short_description: "\u57FA\u56E0\u7BA1\u7406 + \u6DF1\u5EA6\u5B66\u4E60\u5F15\u64CE",
+  category: "efficiency",
+  tags: ["ability"],
+  compatibility: [
+    { product: "openclaw", min_version: "0.5.0" },
+    { product: "nanobot", min_version: "0.1.0" }
+  ],
+  dependencies: [],
+  synergies: [],
+  skill: {
+    name: "genehub-learner",
+    always: true,
+    content: SKILL_CONTENT
+  },
+  rules: [],
+  mcp_servers: [],
+  learning: {
+    force_deep_learn: false,
+    objectives: [
+      "\u638C\u63E1 genehub CLI \u7684\u641C\u7D22\u3001\u5B89\u88C5\u3001\u5B66\u4E60\u3001\u5378\u8F7D\u547D\u4EE4",
+      "\u80FD\u591F\u5904\u7406 learning-tasks/ \u4E2D\u7684\u5B66\u4E60\u4EFB\u52A1\u5E76\u63D0\u4EA4\u7ED3\u679C",
+      "\u80FD\u591F\u751F\u6210\u4E2A\u6027\u5316\u6280\u80FD\u7248\u672C"
+    ],
+    scenarios: []
+  }
+};
+
+// src/learning/prompts.ts
+function generateLearningTaskMarkdown(task) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`task_id: ${task.task_id}`);
+  lines.push(`mode: ${task.mode}`);
+  lines.push(`gene_slug: ${task.gene_slug}`);
+  lines.push(`gene_version: ${task.gene_version}`);
+  lines.push(`callback_path: ${task.callback_path}`);
+  lines.push(`created_at: ${task.created_at}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# \u5B66\u4E60\u4EFB\u52A1: ${task.gene_name}`);
+  lines.push("");
+  lines.push(`> \u7C7B\u522B: ${task.gene_meta.category} | \u7248\u672C: ${task.gene_version}`);
+  lines.push("");
+  lines.push(`${task.gene_meta.description}`);
+  lines.push("");
+  if (task.learning?.objectives?.length) {
+    lines.push("## \u5B66\u4E60\u76EE\u6807");
+    lines.push("");
+    for (const obj of task.learning.objectives) {
+      lines.push(`- [ ] ${obj}`);
+    }
+    lines.push("");
+  }
+  if (task.learning?.scenarios?.length) {
+    lines.push("## \u7EC3\u4E60\u573A\u666F");
+    lines.push("");
+    for (let i = 0; i < task.learning.scenarios.length; i++) {
+      const s = task.learning.scenarios[i];
+      lines.push(`### \u573A\u666F ${i + 1}: ${s.title}`);
+      lines.push("");
+      lines.push(`**\u4E0A\u4E0B\u6587**: ${s.context}`);
+      lines.push("");
+      lines.push(`**\u9884\u671F\u5173\u6CE8\u70B9**: ${s.expected_focus}`);
+      lines.push("");
+      lines.push("**\u4F60\u7684\u7EC3\u4E60**:");
+      lines.push("");
+      lines.push("(\u8BF7\u5728\u6B64\u5904\u8BB0\u5F55\u4F60\u5BF9\u8BE5\u573A\u666F\u7684\u5206\u6790\u548C\u5E94\u5BF9\u65B9\u6848)");
+      lines.push("");
+    }
+  }
+  lines.push("## \u6280\u80FD\u539F\u6587");
+  lines.push("");
+  lines.push("```");
+  lines.push(task.gene_content);
+  lines.push("```");
+  lines.push("");
+  lines.push("## \u5B8C\u6210\u5B66\u4E60");
+  lines.push("");
+  lines.push("\u5B66\u4E60\u5B8C\u6210\u540E\uFF0C\u8BF7\u6267\u884C\u4EE5\u4E0B\u64CD\u4F5C\uFF1A");
+  lines.push("");
+  lines.push(`1. \u5728 \`${task.callback_path}\` \u521B\u5EFA\u5B66\u4E60\u7ED3\u679C\u6587\u4EF6`);
+  lines.push("2. \u5305\u542B YAML front matter\uFF08task_id, decision, self_eval\uFF09");
+  lines.push("3. \u5982\u679C\u4F60\u4E2A\u6027\u5316\u4E86\u6280\u80FD\u5185\u5BB9\uFF0C\u5C06\u4FEE\u6539\u540E\u7684 SKILL.md \u5185\u5BB9\u653E\u5728\u6B63\u6587\u4E2D");
+  lines.push("");
+  lines.push("### \u7ED3\u679C\u6587\u4EF6\u6A21\u677F");
+  lines.push("");
+  lines.push("```markdown");
+  lines.push("---");
+  lines.push(`task_id: ${task.task_id}`);
+  lines.push(`gene_slug: ${task.gene_slug}`);
+  lines.push(`mode: ${task.mode}`);
+  lines.push("decision: learned  # direct_install | learned | failed");
+  lines.push("self_eval: 0.8     # 0.0 - 1.0 \u81EA\u8BC4\u5206");
+  lines.push('reason: "\u6211\u5DF2\u7406\u89E3\u5E76\u4E2A\u6027\u5316\u4E86\u8BE5\u6280\u80FD"');
+  lines.push("---");
+  lines.push("");
+  lines.push("(\u5982\u679C decision \u4E3A learned\uFF0C\u5728\u6B64\u653E\u5165\u4E2A\u6027\u5316\u540E\u7684 SKILL.md \u5185\u5BB9)");
+  lines.push("```");
+  return lines.join("\n");
+}
+function generateForgetTaskMarkdown(slug, name, skillContent, callbackPath) {
+  const taskId = `forget-${slug}-${Date.now()}`;
+  return [
+    "---",
+    `task_id: ${taskId}`,
+    "mode: forget",
+    `gene_slug: ${slug}`,
+    `callback_path: ${callbackPath}`,
+    `created_at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "---",
+    "",
+    `# \u9057\u5FD8\u4EFB\u52A1: ${name}`,
+    "",
+    "\u8BF7\u56DE\u987E\u4F60\u4F7F\u7528\u8BE5\u6280\u80FD\u7684\u7ECF\u9A8C\uFF0C\u7136\u540E\u51B3\u5B9A\uFF1A",
+    "",
+    "- **forgotten**: \u5B8C\u5168\u9057\u5FD8\uFF0C\u6E05\u9664\u6240\u6709\u75D5\u8FF9",
+    "- **simplified**: \u4FDD\u7559\u7CBE\u534E\uFF0C\u7B80\u5316\u4E3A\u66F4\u77ED\u7684\u6280\u80FD\u63CF\u8FF0",
+    "",
+    "## \u5F53\u524D\u6280\u80FD\u5185\u5BB9",
+    "",
+    "```",
+    skillContent,
+    "```",
+    "",
+    `\u8BF7\u5C06\u9057\u5FD8\u7ED3\u679C\u5199\u5165 \`${callbackPath}\``
+  ].join("\n");
+}
+
+// src/learning/engine.ts
+var LearningEngine = class {
+  workspaceDir;
+  adapter;
+  constructor(options) {
+    this.workspaceDir = options.workspaceDir;
+    this.adapter = options.adapter;
+  }
+  get tasksDir() {
+    return join4(this.workspaceDir, "learning-tasks");
+  }
+  get resultsDir() {
+    return join4(this.workspaceDir, "learning-results");
+  }
+  async ensureMetaGeneInstalled() {
+    if (!this.adapter) return false;
+    const installed = await this.adapter.isInstalled("genehub-learner");
+    if (installed) return false;
+    await this.adapter.install(META_LEARNER_MANIFEST, { force: true });
+    await this.injectBootInstruction();
+    return true;
+  }
+  async injectBootInstruction() {
+    const agentsPath = join4(this.workspaceDir, "AGENTS.md");
+    let content;
+    try {
+      content = await readFile4(agentsPath, "utf-8");
+    } catch {
+      return;
+    }
+    const BEGIN = "<!-- genehub:learning-boot -->";
+    const END = "<!-- /genehub:learning-boot -->";
+    if (content.includes(BEGIN)) return;
+    const instruction = [
+      "",
+      BEGIN,
+      "### GeneHub Learning",
+      "",
+      "Check `learning-tasks/` for pending `.md` files. If any exist:",
+      "",
+      "1. Read `skills/genehub-learner/SKILL.md` for the full learning protocol",
+      "2. Process each task file following those instructions",
+      "3. Write results to `learning-results/`",
+      "4. Log what you learned in `memory/YYYY-MM-DD.md`",
+      END
+    ].join("\n");
+    const everySession = content.indexOf("## Every Session");
+    if (everySession !== -1) {
+      const nextSection = content.indexOf("\n## ", everySession + 1);
+      const insertPos = nextSection !== -1 ? nextSection : content.length;
+      content = `${content.slice(0, insertPos)}
+${instruction}
+${content.slice(insertPos)}`;
+    } else {
+      content += `
+${instruction}
+`;
+    }
+    await writeFile4(agentsPath, content, "utf-8");
+  }
+  async createLearningTask(manifest) {
+    await this.ensureMetaGeneInstalled();
+    await mkdir4(this.tasksDir, { recursive: true });
+    await mkdir4(this.resultsDir, { recursive: true });
+    const task = {
+      mode: "learn",
+      task_id: `learn-${manifest.slug}-${Date.now()}`,
+      gene_slug: manifest.slug,
+      gene_name: manifest.name,
+      gene_version: manifest.version,
+      gene_content: manifest.skill.content ?? "",
+      gene_meta: {
+        name: manifest.name,
+        description: manifest.description,
+        category: manifest.category,
+        short_description: manifest.short_description
+      },
+      learning: manifest.learning ? {
+        objectives: manifest.learning.objectives,
+        scenarios: manifest.learning.scenarios,
+        force_deep_learn: manifest.learning.force_deep_learn
+      } : void 0,
+      callback_path: join4(this.resultsDir, `${manifest.slug}.md`),
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const md = generateLearningTaskMarkdown(task);
+    await writeFile4(join4(this.tasksDir, `${manifest.slug}.md`), md, "utf-8");
+    return task;
+  }
+  async createForgetTask(slug, name, skillContent) {
+    await mkdir4(this.tasksDir, { recursive: true });
+    await mkdir4(this.resultsDir, { recursive: true });
+    const callbackPath = join4(this.resultsDir, `${slug}.md`);
+    const md = generateForgetTaskMarkdown(slug, name, skillContent, callbackPath);
+    await writeFile4(join4(this.tasksDir, `${slug}.md`), md, "utf-8");
+  }
+  async checkResult(slug) {
+    const resultPath = join4(this.resultsDir, `${slug}.md`);
+    try {
+      const content = await readFile4(resultPath, "utf-8");
+      return this.parseResult(content);
+    } catch {
+      return null;
+    }
+  }
+  async listPendingTasks() {
+    try {
+      const files = await readdir4(this.tasksDir);
+      const pending = [];
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const slug = file.replace(".md", "");
+        const result = await this.checkResult(slug);
+        if (!result) {
+          pending.push(slug);
+        }
+      }
+      return pending;
+    } catch {
+      return [];
+    }
+  }
+  async listCompletedResults() {
+    const results = [];
+    try {
+      const files = await readdir4(this.resultsDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const content = await readFile4(join4(this.resultsDir, file), "utf-8");
+        const result = this.parseResult(content);
+        if (result) results.push(result);
+      }
+    } catch {
+    }
+    return results;
+  }
+  async applyResult(slug, skillsDir) {
+    const result = await this.checkResult(slug);
+    if (!result) return false;
+    if (result.decision === "learned" && result.content) {
+      const skillDir = join4(skillsDir, slug);
+      await mkdir4(skillDir, { recursive: true });
+      await writeFile4(join4(skillDir, "SKILL.md"), result.content, "utf-8");
+      if (this.adapter?.notifySkillChange) {
+        await this.adapter.notifySkillChange(slug, "updated");
+      }
+    }
+    await this.cleanupTask(slug);
+    return true;
+  }
+  async cleanupTask(slug) {
+    try {
+      await rm4(join4(this.tasksDir, `${slug}.md`));
+    } catch {
+    }
+    try {
+      await rm4(join4(this.resultsDir, `${slug}.md`));
+    } catch {
+    }
+  }
+  parseResult(content) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+    const fm = fmMatch[1];
+    const get = (key) => {
+      const m = fm.match(new RegExp(`^${key}:\\s*["']?(.+?)["']?\\s*$`, "m"));
+      return m?.[1];
+    };
+    const taskId = get("task_id");
+    const geneSlug = get("gene_slug");
+    const mode = get("mode");
+    const decision = get("decision");
+    if (!taskId || !geneSlug || !decision) return null;
+    const bodyStart = content.indexOf("---", 4);
+    const body = bodyStart !== -1 ? content.slice(bodyStart + 3).trim() : void 0;
+    return {
+      task_id: taskId,
+      gene_slug: geneSlug,
+      mode: mode ?? "learn",
+      decision,
+      content: body || void 0,
+      self_eval: get("self_eval") ? Number.parseFloat(get("self_eval")) : void 0,
+      reason: get("reason"),
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+export {
+  GeneHubClient,
+  GenericAdapter,
+  LearningEngine,
+  NanobotAdapter,
+  OpenClawAdapter,
+  detectAdapter,
+  getAdapter
+};
+//# sourceMappingURL=index.js.map