@babyclaw/gateway 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -134,6 +134,9 @@ declare class AdminClient {
     shutdown(): Promise<{
         ok: boolean;
     }>;
+    reloadSkills(): Promise<{
+        ok: boolean;
+    }>;
     private get;
 }
 
@@ -148,6 +151,16 @@ declare function writeConfig({ config }: {
 declare const CONFIG_PATH_ENV_VAR = "BABYCLAW_CONFIG_PATH";
 declare function getDefaultConfigPath(): string;
 declare function getConfigPath(): string;
+declare const DEFAULT_WORKSPACE_ROOT = "~/babyclaw";
+/**
+ * Resolves the workspace path from the config's workspace.root value.
+ * Supports ~ expansion for home-relative paths.
+ * Plain relative paths are resolved against the config file's directory
+ * so the result is deterministic regardless of where the process starts.
+ */
+declare function resolveWorkspaceRoot({ configRoot }: {
+    configRoot: string;
+}): string;
 
 declare function getDefaultConfigTemplate(): string;
 
@@ -204,6 +217,83 @@ declare function resolveLanguageModel({ config }: {
     config: BabyclawConfig;
 }): LanguageModel;
 
+type SkillInstallSpec = {
+    id?: string;
+    kind: "brew" | "node" | "go" | "uv" | "download";
+    label?: string;
+    bins?: string[];
+    os?: string[];
+    formula?: string;
+    package?: string;
+    module?: string;
+    url?: string;
+    archive?: string;
+    extract?: boolean;
+    stripComponents?: number;
+    targetDir?: string;
+};
+type OpenClawSkillMetadata = {
+    always?: boolean;
+    skillKey?: string;
+    primaryEnv?: string;
+    emoji?: string;
+    homepage?: string;
+    os?: string[];
+    requires?: {
+        bins?: string[];
+        anyBins?: string[];
+        env?: string[];
+        config?: string[];
+    };
+    install?: SkillInstallSpec[];
+};
+type SkillFrontmatter = {
+    name: string;
+    description: string;
+    homepage?: string;
+    userInvocable: boolean;
+    disableModelInvocation: boolean;
+    commandDispatch?: string;
+    commandTool?: string;
+    commandArgMode?: string;
+    openclaw?: OpenClawSkillMetadata;
+};
+type SkillEntry = {
+    frontmatter: SkillFrontmatter;
+    slug: string;
+    relativePath: string;
+};
+declare function getSkillKey({ frontmatter, slug, }: {
+    frontmatter: SkillFrontmatter | null;
+    slug: string;
+}): string;
+type SkillsConfig = {
+    entries: Record<string, {
+        enabled: boolean;
+        apiKey?: string;
+        env?: Record<string, string>;
+    }>;
+};
+
+type BundledSkillStatus = {
+    slug: string;
+    frontmatter: SkillFrontmatter | null;
+    enabled: boolean;
+    eligible: boolean;
+    ineligibilityReason: string | null;
+};
+declare function listBundledSkills({ skillsConfig, fullConfig, }: {
+    skillsConfig: SkillsConfig;
+    fullConfig: Record<string, unknown>;
+}): BundledSkillStatus[];
+declare function getEnabledBundledSkills({ skillsConfig, fullConfig, }: {
+    skillsConfig: SkillsConfig;
+    fullConfig: Record<string, unknown>;
+}): SkillEntry[];
+declare function getBundledSkillPath({ slug }: {
+    slug: string;
+}): string | null;
+
 declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
 type LogLevel = (typeof LOG_LEVELS)[number];
 declare const LOG_FORMATS: readonly ["json", "pretty"];
@@ -225,4 +315,4 @@ declare function createChildLogger({ context }: {
     context: Record<string, unknown>;
 }): pino.Logger;
 
-export { AdminClient, type BabyclawConfig, CONFIG_PATH_ENV_VAR, ClawHubError, GatewayRuntime, type GatewayStatus, type InstallSkillResult, type LogFormat, type LogLevel, type LoggingConfig, SUPPORTED_PROVIDERS, SkillAlreadyInstalledError, type SkillSetupResult, babyclawConfigSchema, createChildLogger, createLogger, getAdminSocketPath, getConfigPath, getDefaultConfigPath, getDefaultConfigTemplate, getLogger, installSkillFromClawHub, loadConfig, loadConfigRaw, resolveLanguageModel, runSkillSetup, writeConfig };
+export { AdminClient, type BabyclawConfig, type BundledSkillStatus, CONFIG_PATH_ENV_VAR, ClawHubError, DEFAULT_WORKSPACE_ROOT, GatewayRuntime, type GatewayStatus, type InstallSkillResult, type LogFormat, type LogLevel, type LoggingConfig, SUPPORTED_PROVIDERS, SkillAlreadyInstalledError, type SkillSetupResult, babyclawConfigSchema, createChildLogger, createLogger, getAdminSocketPath, getBundledSkillPath, getConfigPath, getDefaultConfigPath, getDefaultConfigTemplate, getEnabledBundledSkills, getLogger, getSkillKey, installSkillFromClawHub, listBundledSkills, loadConfig, loadConfigRaw, resolveLanguageModel, resolveWorkspaceRoot, runSkillSetup, writeConfig };

package/dist/index.js

@@ -5,7 +5,8 @@ var __export = (target, all) => {
 };
 
 // src/runtime.ts
-import { resolve as resolve5 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { getBundledSkillsDir } from "@babyclaw/skills";
 
 // src/ai/agent.ts
 import {
@@ -2042,9 +2043,26 @@ import { z } from "zod";
 // src/utils/path.ts
 import { resolve, sep } from "path";
 import { stat } from "fs/promises";
+var BUNDLED_SKILLS_PREFIX = "bundled-skills/";
 function normalizeSeparators({ path }) {
   return path.replaceAll("\\", "/");
 }
+function resolveBundledSkillPath({
+  bundledSkillsDir,
+  requestedPath
+}) {
+  const relative3 = requestedPath.slice(BUNDLED_SKILLS_PREFIX.length);
+  const normalized = normalizeSeparators({ path: relative3 }).trim();
+  if (normalized.length === 0) {
+    throw new Error("Path is required");
+  }
+  const absoluteRoot = resolve(bundledSkillsDir);
+  const absoluteTarget = resolve(absoluteRoot, normalized);
+  if (!isSubPath({ parent: absoluteRoot, child: absoluteTarget })) {
+    throw new Error("Path escapes bundled skills root");
+  }
+  return absoluteTarget;
+}
 function resolveWorkspacePath({
   workspaceRoot,
   requestedPath
@@ -3801,10 +3819,25 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_READ_FAILED",
         input: { path, format },
         action: async () => {
-          const absolutePath = resolveWorkspacePath({
-            workspaceRoot: context.workspaceRoot,
-            requestedPath: path
-          });
+          const isBundled = path.startsWith(BUNDLED_SKILLS_PREFIX);
+          let absolutePath;
+          if (isBundled) {
+            if (!context.bundledSkillsDir) {
+              throw new ToolExecutionError({
+                code: "BUNDLED_SKILLS_UNAVAILABLE",
+                message: "Bundled skills directory is not configured"
+              });
+            }
+            absolutePath = resolveBundledSkillPath({
+              bundledSkillsDir: context.bundledSkillsDir,
+              requestedPath: path
+            });
+          } else {
+            absolutePath = resolveWorkspacePath({
+              workspaceRoot: context.workspaceRoot,
+              requestedPath: path
+            });
+          }
           const raw = await readFile6(absolutePath, "utf8");
           ensurePayloadWithinLimit({
             value: raw,
@@ -3862,6 +3895,12 @@ function createWorkspaceTools({ context }) {
           hasValue: value !== void 0
         },
         action: async () => {
+          if (path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be written to"
+            });
+          }
           const absolutePath = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: path
@@ -4001,6 +4040,12 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_DELETE_FAILED",
         input: { path, recursive },
         action: async () => {
+          if (path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be deleted"
+            });
+          }
           const absolutePath = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: path
@@ -4037,6 +4082,12 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_MOVE_FAILED",
         input: { from_path, to_path, overwrite },
         action: async () => {
+          if (from_path.startsWith(BUNDLED_SKILLS_PREFIX) || to_path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be moved"
+            });
+          }
           const fromAbsolute = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: from_path
@@ -4217,44 +4268,15 @@ function createUnifiedTools({
   };
 }
 
-// src/onboarding/personality.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join9 } from "path";
-function getPersonalityFilePaths({ workspacePath }) {
-  return {
-    identityPath: join9(workspacePath, "IDENTITY.md"),
-    soulPath: join9(workspacePath, "SOUL.md"),
-    userPath: join9(workspacePath, "USER.md")
-  };
-}
-async function readPersonalityFiles({
-  workspacePath
+// src/bundled-skills/index.ts
+import { listBundledSlugs, readBundledSkillContent, getBundledSkillInfo } from "@babyclaw/skills";
+
+// src/workspace/skills/types.ts
+function getSkillKey({
+  frontmatter,
+  slug
 }) {
-  const { identityPath, soulPath, userPath } = getPersonalityFilePaths({ workspacePath });
-  const [identity, soul, user] = await Promise.all([
-    readOptionalFile2({ path: identityPath }),
-    readOptionalFile2({ path: soulPath }),
-    readOptionalFile2({ path: userPath })
-  ]);
-  return {
-    identity,
-    soul,
-    user
-  };
-}
-function hasCompletePersonalityFiles(files) {
-  return typeof files.identity === "string" && files.identity.trim().length > 0 && typeof files.soul === "string" && files.soul.trim().length > 0 && typeof files.user === "string" && files.user.trim().length > 0;
-}
-async function readOptionalFile2({ path }) {
-  try {
-    return await readFile7(path, "utf8");
-  } catch (error) {
-    const maybeErrno = error;
-    if (maybeErrno.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
+  return frontmatter?.openclaw?.skillKey ?? frontmatter?.name ?? slug;
 }
 
 // src/workspace/skills/eligibility.ts
@@ -4264,54 +4286,84 @@ function getEligibleSkills({
   skillsConfig,
   fullConfig
 }) {
-  return skills.filter((skill) => shouldIncludeSkill({ skill, skillsConfig, fullConfig }));
+  return skills.filter((skill) => {
+    const { frontmatter, slug } = skill;
+    const entry = skillsConfig.entries[getSkillKey({ frontmatter, slug })];
+    if (entry?.enabled === false) return false;
+    return checkSkillEligibility({ frontmatter, skillsConfig, fullConfig }).eligible;
+  });
 }
-function shouldIncludeSkill({
-  skill,
+function checkSkillEligibility({
+  frontmatter,
   skillsConfig,
   fullConfig
 }) {
-  const { frontmatter } = skill;
+  if (frontmatter.disableModelInvocation) {
+    return { eligible: false, reason: "Model invocation disabled" };
+  }
   const openclaw = frontmatter.openclaw;
-  const skillKey = openclaw?.skillKey ?? frontmatter.name;
-  const entry = skillsConfig.entries[skillKey];
-  if (entry?.enabled === false) return false;
-  if (frontmatter.disableModelInvocation) return false;
   if (openclaw?.os && openclaw.os.length > 0) {
-    if (!openclaw.os.includes(process.platform)) return false;
+    if (!openclaw.os.includes(process.platform)) {
+      return {
+        eligible: false,
+        reason: `Requires OS: ${openclaw.os.join(", ")} (current: ${process.platform})`
+      };
+    }
+  }
+  if (openclaw?.always) {
+    return { eligible: true, reason: null };
   }
-  if (openclaw?.always) return true;
   const requires = openclaw?.requires;
-  if (!requires) return true;
+  if (!requires) {
+    return { eligible: true, reason: null };
+  }
   if (requires.bins && requires.bins.length > 0) {
-    if (!requires.bins.every((bin) => binaryExists({ name: bin }))) return false;
+    const missing = requires.bins.filter((bin) => !binaryExists({ name: bin }));
+    if (missing.length > 0) {
+      return { eligible: false, reason: `Missing binaries: ${missing.join(", ")}` };
+    }
   }
   if (requires.anyBins && requires.anyBins.length > 0) {
-    if (!requires.anyBins.some((bin) => binaryExists({ name: bin }))) return false;
+    if (!requires.anyBins.some((bin) => binaryExists({ name: bin }))) {
+      return {
+        eligible: false,
+        reason: `Requires at least one of: ${requires.anyBins.join(", ")}`
+      };
+    }
   }
   if (requires.env && requires.env.length > 0) {
+    const skillKey = openclaw?.skillKey ?? frontmatter.name;
+    const entry = skillsConfig.entries[skillKey];
     const primaryEnv = openclaw?.primaryEnv;
     const hasApiKeyInConfig = Boolean(entry?.apiKey);
     for (const envVar of requires.env) {
       if (process.env[envVar]) continue;
       if (primaryEnv === envVar && hasApiKeyInConfig) continue;
-      return false;
+      return { eligible: false, reason: `Missing environment variable: ${envVar}` };
     }
   }
   if (requires.config && requires.config.length > 0) {
     for (const configPath of requires.config) {
-      if (!getConfigValue({ config: fullConfig, path: configPath })) return false;
+      if (!getConfigValue({ config: fullConfig, path: configPath })) {
+        return { eligible: false, reason: `Missing config value: ${configPath}` };
+      }
     }
   }
-  return true;
+  return { eligible: true, reason: null };
 }
+var binaryExistsCache = /* @__PURE__ */ new Map();
 function binaryExists({ name }) {
+  const cached = binaryExistsCache.get(name);
+  if (cached !== void 0) return cached;
+  let exists;
   try {
     execFileSync("which", [name], { stdio: "ignore" });
-    return true;
+    exists = true;
   } catch {
-    return false;
+    exists = false;
   }
+  binaryExistsCache.set(name, exists);
+  return exists;
 }
 function getConfigValue({
   config,
@@ -4326,6 +4378,94 @@ function getConfigValue({
   return current;
 }
 
+// src/bundled-skills/index.ts
+function listBundledSkills({
+  skillsConfig,
+  fullConfig
+}) {
+  const slugs = listBundledSlugs();
+  return slugs.map((slug) => {
+    const content = readBundledSkillContent({ slug });
+    if (!content) {
+      return {
+        slug,
+        frontmatter: null,
+        enabled: false,
+        eligible: false,
+        ineligibilityReason: "Could not read SKILL.md"
+      };
+    }
+    const raw = parseFrontmatter({ content });
+    const frontmatter = raw ? buildFrontmatter({ raw }) : null;
+    const skillKey = getSkillKey({ frontmatter, slug });
+    const entry = skillsConfig.entries[skillKey];
+    const enabled = entry?.enabled === true;
+    const { eligible, reason } = frontmatter ? checkSkillEligibility({ frontmatter, skillsConfig, fullConfig }) : { eligible: false, reason: "Invalid frontmatter" };
+    return {
+      slug,
+      frontmatter,
+      enabled,
+      eligible,
+      ineligibilityReason: reason
+    };
+  });
+}
+function getEnabledBundledSkills({
+  skillsConfig,
+  fullConfig
+}) {
+  const all = listBundledSkills({ skillsConfig, fullConfig });
+  return all.filter((s) => s.enabled && s.eligible && s.frontmatter).map((s) => ({
+    frontmatter: s.frontmatter,
+    slug: s.slug,
+    relativePath: `bundled-skills/${s.slug}/SKILL.md`
+  }));
+}
+function getBundledSkillPath({ slug }) {
+  const info = getBundledSkillInfo({ slug });
+  return info?.skillDir ?? null;
+}
+
+// src/onboarding/personality.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join9 } from "path";
+function getPersonalityFilePaths({ workspacePath }) {
+  return {
+    identityPath: join9(workspacePath, "IDENTITY.md"),
+    soulPath: join9(workspacePath, "SOUL.md"),
+    userPath: join9(workspacePath, "USER.md")
+  };
+}
+async function readPersonalityFiles({
+  workspacePath
+}) {
+  const { identityPath, soulPath, userPath } = getPersonalityFilePaths({ workspacePath });
+  const [identity, soul, user] = await Promise.all([
+    readOptionalFile2({ path: identityPath }),
+    readOptionalFile2({ path: soulPath }),
+    readOptionalFile2({ path: userPath })
+  ]);
+  return {
+    identity,
+    soul,
+    user
+  };
+}
+function hasCompletePersonalityFiles(files) {
+  return typeof files.identity === "string" && files.identity.trim().length > 0 && typeof files.soul === "string" && files.soul.trim().length > 0 && typeof files.user === "string" && files.user.trim().length > 0;
+}
+async function readOptionalFile2({ path }) {
+  try {
+    return await readFile7(path, "utf8");
+  } catch (error) {
+    const maybeErrno = error;
+    if (maybeErrno.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
 // src/agent/context.ts
 async function loadAgentContext({
   workspacePath,
@@ -4338,7 +4478,11 @@ async function loadAgentContext({
     readWorkspaceGuide({ workspacePath }),
     scanWorkspaceSkills({ workspacePath })
   ]);
-  const skills = getEligibleSkills({ skills: allSkills, skillsConfig, fullConfig });
+  const workspaceSkills = getEligibleSkills({ skills: allSkills, skillsConfig, fullConfig });
+  const bundledSkills = getEnabledBundledSkills({ skillsConfig, fullConfig });
+  const workspaceSlugs = new Set(workspaceSkills.map((s) => s.slug));
+  const dedupedBundled = bundledSkills.filter((s) => !workspaceSlugs.has(s.slug));
+  const skills = [...workspaceSkills, ...dedupedBundled];
   const personalityFiles = hasCompletePersonalityFiles(rawPersonalityFiles) ? rawPersonalityFiles : void 0;
   return { personalityFiles, toolNotesContent, agentsContent, skills };
 }
@@ -4519,6 +4663,7 @@ var AgentTurnOrchestrator = class {
     if (abortSignal.aborted) return;
     const {
       workspacePath,
+      bundledSkillsDir,
       aiAgent,
       sessionManager,
       schedulerService,
@@ -4618,6 +4763,7 @@ ${description}`;
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: event.platform,
         chatId: event.chatId,
@@ -5932,11 +6078,11 @@ var ChatRegistry = class {
 
 // src/config/loader.ts
 import { access, mkdir as mkdir5, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 
 // src/config/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
+import { dirname as dirname5, join as join11, resolve as resolve4, isAbsolute } from "path";
 var CONFIG_PATH_ENV_VAR = "BABYCLAW_CONFIG_PATH";
 function getDefaultConfigPath() {
   return join11(homedir2(), ".babyclaw", "babyclaw.json");
@@ -5948,6 +6094,19 @@ function getConfigPath() {
   }
   return getDefaultConfigPath();
 }
+function getConfigDir() {
+  return dirname5(getConfigPath());
+}
+var DEFAULT_WORKSPACE_ROOT = "~/babyclaw";
+function resolveWorkspaceRoot({ configRoot }) {
+  if (configRoot === "~" || configRoot.startsWith("~/")) {
+    return join11(homedir2(), configRoot.slice(2));
+  }
+  if (isAbsolute(configRoot)) {
+    return configRoot;
+  }
+  return resolve4(getConfigDir(), configRoot);
+}
 
 // src/config/schema.ts
 import { z as z11 } from "zod";
@@ -6101,9 +6260,9 @@ var babyclawConfigSchema = z11.object({
     timezone: "UTC"
   }),
   workspace: z11.object({
-    root: z11.string().min(1).default(".")
+    root: z11.string().min(1).default("~/babyclaw")
   }).strict().default({
-    root: "."
+    root: "~/babyclaw"
   }),
   session: z11.object({
     maxMessagesPerSession: z11.number().int().positive().default(120),
@@ -6163,7 +6322,7 @@ var DEFAULT_CONFIG_TEMPLATE = {
     timezone: "UTC"
   },
   workspace: {
-    root: "."
+    root: "~/babyclaw"
   },
   session: {
     maxMessagesPerSession: 120,
@@ -6238,7 +6397,7 @@ async function loadConfigRaw() {
 }
 async function writeConfig({ config }) {
   const configPath = getConfigPath();
-  await mkdir5(dirname5(configPath), { recursive: true });
+  await mkdir5(dirname6(configPath), { recursive: true });
   await writeFile5(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 async function ensureConfigFileExists({ configPath }) {
@@ -6249,7 +6408,7 @@ async function ensureConfigFileExists({ configPath }) {
     if (error.code !== "ENOENT") {
       throw error;
     }
-    await mkdir5(dirname5(configPath), { recursive: true });
+    await mkdir5(dirname6(configPath), { recursive: true });
     await writeFile5(configPath, getDefaultConfigTemplate(), "utf8");
     getLogger().warn({ configPath }, "Created config file. Fill required secrets and restart.");
   }
@@ -6421,6 +6580,7 @@ var HeartbeatExecutor = class {
         toolDeps: this.toolDeps,
         executionContext: {
           workspaceRoot: workspacePath,
+          bundledSkillsDir: this.toolDeps.bundledSkillsDir,
           botTimezone: schedulerService.getTimezone(),
           platform: mainChat.platform,
           chatId: platformChatId,
@@ -6877,6 +7037,7 @@ var SchedulerExecutor = class {
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir: this.toolDeps.bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: this.channelSender.platform,
         chatId: chatIdStr,
@@ -7623,13 +7784,13 @@ function createDatabase({ workspacePath }) {
 }
 
 // src/database/migrate.ts
-import { dirname as dirname6, resolve as resolve4 } from "path";
+import { dirname as dirname7, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-var __dirname = dirname6(fileURLToPath(import.meta.url));
+var __dirname = dirname7(fileURLToPath(import.meta.url));
 function applyMigrations({ workspacePath }) {
   const db = createDatabase({ workspacePath });
-  const migrationsFolder = resolve4(__dirname, "..", "drizzle");
+  const migrationsFolder = resolve5(__dirname, "..", "drizzle");
   migrate(db, { migrationsFolder });
 }
 
@@ -7667,7 +7828,8 @@ var GatewayRuntime = class {
         },
         "Gateway configuration summary"
       );
-      const workspacePath = resolve5(process.cwd(), config.workspace.root);
+      const workspacePath = resolveWorkspaceRoot({ configRoot: config.workspace.root });
+      mkdirSync3(workspacePath, { recursive: true });
       log.info("Applying database migrations...");
       applyMigrations({ workspacePath });
       log.info("Database migrations applied");
@@ -7751,6 +7913,7 @@ var GatewayRuntime = class {
       const adminSocketPath = getAdminSocketPath();
       const toolDeps = {
         workspacePath,
+        bundledSkillsDir: getBundledSkillsDir(),
         aiAgent,
         sessionManager,
         schedulerService,
@@ -7856,6 +8019,16 @@ var GatewayRuntime = class {
               void this.stop().then(() => process.exit(0));
             });
             return { ok: true };
+          },
+          "/reload-skills": async () => {
+            const freshConfig = await loadConfigRaw();
+            if (!freshConfig) {
+              return { ok: false, error: "config_not_found" };
+            }
+            toolDeps.skillsConfig = freshConfig.skills;
+            toolDeps.fullConfig = freshConfig;
+            log.info("Skills configuration reloaded via admin socket");
+            return { ok: true };
           }
         }
       });
@@ -7956,6 +8129,9 @@ var AdminClient = class {
   async shutdown() {
     return this.get({ path: "/shutdown" });
   }
+  async reloadSkills() {
+    return this.get({ path: "/reload-skills" });
+  }
   get({ path }) {
     return new Promise((resolve6, reject) => {
       const req = request(
@@ -7997,6 +8173,7 @@ export {
   AdminClient,
   CONFIG_PATH_ENV_VAR,
   ClawHubError,
+  DEFAULT_WORKSPACE_ROOT,
   GatewayRuntime,
   SUPPORTED_PROVIDERS,
   SkillAlreadyInstalledError,
@@ -8004,14 +8181,19 @@ export {
   createChildLogger,
   createLogger,
   getAdminSocketPath,
+  getBundledSkillPath,
   getConfigPath,
   getDefaultConfigPath,
   getDefaultConfigTemplate,
+  getEnabledBundledSkills,
   getLogger,
+  getSkillKey,
   installSkillFromClawHub,
+  listBundledSkills,
   loadConfig,
   loadConfigRaw,
   resolveLanguageModel,
+  resolveWorkspaceRoot,
   runSkillSetup,
   writeConfig
 };