openfox 1.6.91 → 1.6.92

package/dist/{chunk-CL2ZPJAG.js → chunk-ARJIHQ3S.js}

@@ -1,8 +1,7 @@
 import {
   SETTINGS_KEYS,
   deleteSetting,
-  getSetting,
-  setSetting
+  getSetting
 } from "./chunk-PQCFNTFJ.js";
 import {
   getProject
@@ -28,11 +27,11 @@ import {
   getBackendCapabilities,
   getModelProfile,
   streamWithSegments
-} from "./chunk-STUSQVXQ.js";
+} from "./chunk-RJIPM7CO.js";
 import {
   getCurrentContextWindowId,
   getEventStore
-} from "./chunk-6P5WQP6Y.js";
+} from "./chunk-YTPPQK55.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -59,7 +58,7 @@ import {
 } from "./chunk-CQGTEGKL.js";
 import {
   getRuntimeConfig
-} from "./chunk-B5AP3RSV.js";
+} from "./chunk-RW25DL5R.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -1058,28 +1057,105 @@ Error: ${toolResult.error}` : `Error: ${toolResult.error}`;
 }
 
 // src/server/agents/registry.ts
-import { readdir, readFile as readFile2, writeFile, mkdir, access as access2, unlink } from "fs/promises";
-import { join as join2, dirname as dirname2 } from "path";
-import { constants as constants2 } from "fs";
+import { readdir as readdir2, readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, access as access3, unlink as unlink2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { constants as constants3 } from "fs";
 import { fileURLToPath } from "url";
+import matter2 from "gray-matter";
+
+// src/server/shared/item-loader.ts
+import { readdir, readFile as readFile2, access as access2, writeFile, mkdir, unlink } from "fs/promises";
+import { join as join2 } from "path";
+import { constants as constants2 } from "fs";
 import matter from "gray-matter";
+async function pathExists(path) {
+  try {
+    await access2(path, constants2.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDefaultIds(dir, extension) {
+  try {
+    const files = (await readdir(dir)).filter((f) => f.endsWith(extension));
+    return files.map((f) => f.replace(extension, ""));
+  } catch {
+    return [];
+  }
+}
+async function loadItemsFromDir(dir, options) {
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(options.extension));
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile2(join2(dir, file), "utf-8");
+      const { data, content } = matter(raw);
+      if (data.id && content.trim()) {
+        items.push({
+          metadata: data,
+          prompt: content.trim()
+        });
+      } else {
+        logger.warn(`Skipping invalid ${options.logName} file`, { file });
+      }
+    } catch (err) {
+      logger.warn(`Failed to parse ${options.logName} file`, {
+        file,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return items;
+}
+async function saveItemToDir(dir, item, ext, serialize) {
+  if (!await pathExists(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  const meta = item.metadata;
+  const filePath = join2(dir, `${meta.id}${ext}`);
+  await writeFile(filePath, serialize(item), "utf-8");
+}
+var jsonSerializer = (item) => JSON.stringify(item, null, 2) + "\n";
+async function deleteItemFromDir(dir, id, ext) {
+  const filePath = join2(dir, `${id}${ext}`);
+  try {
+    await unlink(filePath);
+    return { success: true };
+  } catch {
+    return { success: false };
+  }
+}
+
+// src/server/agents/registry.ts
 var __bundleDir = dirname2(fileURLToPath(import.meta.url));
-var DEFAULTS_DIR = join2(__bundleDir, "defaults");
-var DEFAULTS_DIR_ALT = join2(__bundleDir, "agent-defaults");
+var DEFAULTS_DIR = join3(__bundleDir, "defaults");
+var DEFAULTS_DIR_ALT = join3(__bundleDir, "agent-defaults");
 var AGENT_EXTENSION = ".agent.md";
 function getAgentsDir(configDir) {
-  return join2(configDir, "agents");
+  return join3(configDir, "agents");
 }
-async function pathExists(path) {
+function getProjectAgentsDir(projectDir) {
+  return join3(projectDir, ".openfox", "agents");
+}
+async function pathExists2(path) {
   try {
-    await access2(path, constants2.R_OK);
+    await access3(path, constants3.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function parseAgentFile(raw, filename) {
-  const { data, content } = matter(raw);
+  const { data, content } = matter2(raw);
   const meta = data;
   if (!meta["id"] || !content.trim()) {
     logger.warn("Skipping invalid agent file", { filename });
@@ -1097,19 +1173,19 @@ function parseAgentFile(raw, filename) {
   return { metadata, prompt: content.trim() };
 }
 async function loadAgentsFromDir(dir) {
-  if (!await pathExists(dir)) {
+  if (!await pathExists2(dir)) {
     return [];
   }
   let files;
   try {
-    files = (await readdir(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
+    files = (await readdir2(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
   } catch {
     return [];
   }
   const agents = [];
   for (const file of files) {
     try {
-      const raw = await readFile2(join2(dir, file), "utf-8");
+      const raw = await readFile3(join3(dir, file), "utf-8");
       const agent = parseAgentFile(raw, file);
       if (agent) {
         agents.push(agent);
@@ -1128,7 +1204,10 @@ async function loadDefaultAgents() {
 async function loadUserAgents(configDir) {
   return loadAgentsFromDir(getAgentsDir(configDir));
 }
-async function loadAllAgents(configDir) {
+async function loadProjectAgents(projectDir) {
+  return loadAgentsFromDir(getProjectAgentsDir(projectDir));
+}
+async function loadAllAgents(configDir, projectDir) {
   const [defaultAgents, userAgents] = await Promise.all([loadDefaultAgents(), loadUserAgents(configDir)]);
   const agentMap = /* @__PURE__ */ new Map();
   for (const agent of defaultAgents) {
@@ -1137,12 +1216,40 @@ async function loadAllAgents(configDir) {
   for (const agent of userAgents) {
     agentMap.set(agent.metadata.id, agent);
   }
+  if (projectDir) {
+    const projectAgents = await loadProjectAgents(projectDir);
+    for (const agent of projectAgents) {
+      agentMap.set(agent.metadata.id, agent);
+    }
+  }
   return Array.from(agentMap.values());
 }
+async function saveAgentToProject(projectDir, agent) {
+  await saveItemToDir(
+    getProjectAgentsDir(projectDir),
+    agent,
+    AGENT_EXTENSION,
+    (a) => matter2.stringify(a.prompt, a.metadata)
+  );
+}
+async function deleteProjectAgent(projectDir, agentId) {
+  const agentsDir = getProjectAgentsDir(projectDir);
+  const paths = getAgentFilePaths(agentsDir, agentId);
+  for (const filePath of paths) {
+    try {
+      await unlink2(filePath);
+      return { success: true };
+    } catch {
+      continue;
+    }
+  }
+  return { success: false };
+}
 async function loadAllAgentsDefault() {
   try {
-    const configDir = getGlobalConfigDir(getRuntimeConfig().mode ?? "production");
-    return await loadAllAgents(configDir);
+    const config = getRuntimeConfig();
+    const configDir = getGlobalConfigDir(config.mode ?? "production");
+    return await loadAllAgents(configDir, config.workdir);
   } catch {
     return loadDefaultAgents();
   }
@@ -1150,24 +1257,20 @@ async function loadAllAgentsDefault() {
 async function getDefaultAgentIds() {
   for (const dir of [DEFAULTS_DIR, DEFAULTS_DIR_ALT]) {
     try {
-      const files = (await readdir(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
+      const files = (await readdir2(dir)).filter((f) => f.endsWith(AGENT_EXTENSION));
       return files.map((f) => f.replace(AGENT_EXTENSION, ""));
     } catch {
     }
   }
   return [];
 }
-async function getDefaultAgentContent(agentId) {
-  const defaults = await loadDefaultAgents();
-  return defaults.find((a) => a.metadata.id === agentId) ?? null;
-}
 async function isDefaultAgent(agentId) {
   const defaultIds = await getDefaultAgentIds();
   return defaultIds.includes(agentId);
 }
 function getAgentFilePaths(agentsDir, agentId) {
   const hyphenated = agentId.replace(/_/g, "-");
-  return [join2(agentsDir, `${agentId}${AGENT_EXTENSION}`), join2(agentsDir, `${hyphenated}${AGENT_EXTENSION}`)];
+  return [join3(agentsDir, `${agentId}${AGENT_EXTENSION}`), join3(agentsDir, `${hyphenated}${AGENT_EXTENSION}`)];
 }
 function findAgentById(agentId, agents) {
   return agents.find((a) => a.metadata.id === agentId);
@@ -1178,24 +1281,32 @@ function getSubAgents(agents) {
 function getTopLevelAgents(agents) {
   return agents.filter((a) => !a.metadata.subagent);
 }
-async function agentExists(configDir, agentId) {
+async function agentExists(configDir, agentId, projectDir) {
   const agentsDir = getAgentsDir(configDir);
   const paths = getAgentFilePaths(agentsDir, agentId);
   for (const filePath of paths) {
-    if (await pathExists(filePath)) {
+    if (await pathExists2(filePath)) {
       return true;
     }
   }
+  if (projectDir) {
+    const projectPaths = getAgentFilePaths(getProjectAgentsDir(projectDir), agentId);
+    for (const filePath of projectPaths) {
+      if (await pathExists2(filePath)) {
+        return true;
+      }
+    }
+  }
   return false;
 }
 async function saveAgent(configDir, agent) {
   const agentsDir = getAgentsDir(configDir);
-  if (!await pathExists(agentsDir)) {
-    await mkdir(agentsDir, { recursive: true });
+  if (!await pathExists2(agentsDir)) {
+    await mkdir2(agentsDir, { recursive: true });
   }
-  const filePath = join2(agentsDir, `${agent.metadata.id}${AGENT_EXTENSION}`);
-  const content = matter.stringify(agent.prompt, agent.metadata);
-  await writeFile(filePath, content, "utf-8");
+  const filePath = join3(agentsDir, `${agent.metadata.id}${AGENT_EXTENSION}`);
+  const content = matter2.stringify(agent.prompt, agent.metadata);
+  await writeFile2(filePath, content, "utf-8");
 }
 async function deleteAgent(configDir, agentId) {
   const isDefault = await isDefaultAgent(agentId);
@@ -1206,7 +1317,7 @@ async function deleteAgent(configDir, agentId) {
   const paths = getAgentFilePaths(agentsDir, agentId);
   for (const filePath of paths) {
     try {
-      await unlink(filePath);
+      await unlink2(filePath);
       return { success: true };
     } catch {
       continue;
@@ -1216,7 +1327,7 @@ async function deleteAgent(configDir, agentId) {
 }
 
 // src/server/tools/read.ts
-import { readFile as readFile4, stat } from "fs/promises";
+import { readFile as readFile5, stat } from "fs/promises";
 import { extname } from "path";
 
 // src/server/tools/types.ts
@@ -1247,7 +1358,7 @@ import { resolve as resolve2, isAbsolute } from "path";
 
 // src/server/tools/path-security.ts
 import { realpath } from "fs/promises";
-import { resolve, normalize, join as join3, basename, sep } from "path";
+import { resolve, normalize, join as join4, basename, sep } from "path";
 import { homedir, tmpdir } from "os";
 var SAFE_PATHS = /* @__PURE__ */ new Set([
   "/dev/null",
@@ -1381,7 +1492,7 @@ function extractAbsolutePathsFromCommand(command) {
       }
     } else if (content.startsWith("~")) {
       const pathPart = content.slice(1);
-      const fullPath = join3(home, pathPart);
+      const fullPath = join4(home, pathPart);
       const resolved = normalize(resolve(fullPath));
       if (!isSafePath(resolved)) {
         paths.push(resolved);
@@ -1691,7 +1802,7 @@ function createTool(name, definition, handler2) {
 
 // src/server/tools/file-tracker.ts
 import { createHash } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { resolve as resolve3 } from "path";
 var FileNotReadError = class extends Error {
   constructor(path) {
@@ -1709,7 +1820,7 @@ var FileChangedExternallyError = class extends Error {
 };
 async function computeFileHash(filePath) {
   try {
-    const content = await readFile3(filePath);
+    const content = await readFile4(filePath);
     const hash = createHash("sha256");
     hash.update(content);
     return hash.digest("hex");
@@ -1844,7 +1955,7 @@ var readFileTool = createTool(
     } catch {
       return helpers.error(`File not found: ${args.path}`);
     }
-    const rawBuffer = await readFile4(fullPath);
+    const rawBuffer = await readFile5(fullPath);
     const mimeType = detectImageType(rawBuffer, args.path);
     if (mimeType) {
       const base64Data = rawBuffer.toString("base64");
@@ -1890,7 +2001,7 @@ var readFileTool = createTool(
 );
 
 // src/server/tools/write.ts
-import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { dirname as dirname3 } from "path";
 
 // src/server/tools/diagnostics.ts
@@ -1951,8 +2062,8 @@ var writeFileTool = createTool(
       return helpers.error(validation.error?.message ?? "File validation failed");
     }
     const dir = dirname3(fullPath);
-    await mkdir2(dir, { recursive: true });
-    await writeFile2(fullPath, args.content, "utf-8");
+    await mkdir3(dir, { recursive: true });
+    await writeFile3(fullPath, args.content, "utf-8");
     const lineCount = args.content.split("\n").length;
     const byteCount = Buffer.byteLength(args.content, "utf-8");
     let output = `Successfully wrote ${lineCount} lines (${byteCount} bytes) to ${args.path}`;
@@ -1970,7 +2081,7 @@ var writeFileTool = createTool(
 );
 
 // src/server/tools/edit.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 
 // src/server/tools/edit-context.ts
 var CONTEXT_LINES = 4;
@@ -2126,7 +2237,7 @@ var editFileTool = createTool(
     }
     let content;
     try {
-      content = await readFile5(fullPath, "utf-8");
+      content = await readFile6(fullPath, "utf-8");
     } catch {
       return helpers.error(`File not found: ${args.path}`);
     }
@@ -2191,7 +2302,7 @@ Make sure whitespace and indentation match exactly.`
       /\n/g,
       fileLineEnding === "crlf" ? "\r\n" : fileLineEnding === "cr" ? "\r" : "\n"
     );
-    await writeFile3(fullPath, newContent, "utf-8");
+    await writeFile4(fullPath, newContent, "utf-8");
     let output = `Successfully replaced ${replaceAll ? occurrences : 1} occurrence(s) in ${args.path}`;
     let diagnostics = [];
     if (context.lspManager) {
@@ -2692,66 +2803,10 @@ function createToolProgressHandler(eventStore, messageId, callId, sessionId) {
 }
 
 // src/server/skills/registry.ts
-import { writeFile as writeFile4, mkdir as mkdir3, unlink as unlink2 } from "fs/promises";
+import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3 } from "fs/promises";
 import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import matter3 from "gray-matter";
-
-// src/server/shared/item-loader.ts
-import { readdir as readdir2, readFile as readFile6, access as access3 } from "fs/promises";
-import { join as join4 } from "path";
-import { constants as constants3 } from "fs";
-import matter2 from "gray-matter";
-async function pathExists2(path) {
-  try {
-    await access3(path, constants3.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getDefaultIds(dir, extension) {
-  try {
-    const files = (await readdir2(dir)).filter((f) => f.endsWith(extension));
-    return files.map((f) => f.replace(extension, ""));
-  } catch {
-    return [];
-  }
-}
-async function loadItemsFromDir(dir, options) {
-  if (!await pathExists2(dir)) {
-    return [];
-  }
-  let files;
-  try {
-    files = (await readdir2(dir)).filter((f) => f.endsWith(options.extension));
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const file of files) {
-    try {
-      const raw = await readFile6(join4(dir, file), "utf-8");
-      const { data, content } = matter2(raw);
-      if (data.id && content.trim()) {
-        items.push({
-          metadata: data,
-          prompt: content.trim()
-        });
-      } else {
-        logger.warn(`Skipping invalid ${options.logName} file`, { file });
-      }
-    } catch (err) {
-      logger.warn(`Failed to parse ${options.logName} file`, {
-        file,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return items;
-}
-
-// src/server/skills/registry.ts
 var __bundleDir2 = dirname4(fileURLToPath2(import.meta.url));
 var DEFAULTS_DIR2 = join5(__bundleDir2, "defaults");
 var DEFAULTS_DIR_ALT2 = join5(__bundleDir2, "skill-defaults");
@@ -2760,6 +2815,9 @@ var SKILL_SETTING_PREFIX = "skill.enabled.";
 function getSkillsDir(configDir) {
   return join5(configDir, "skills");
 }
+function getProjectSkillsDir(projectDir) {
+  return join5(projectDir, ".openfox", "skills");
+}
 async function loadDefaultSkills() {
   let defaults = await loadItemsFromDir(DEFAULTS_DIR2, {
     extension: SKILL_EXTENSION,
@@ -2779,7 +2837,13 @@ async function loadUserSkills(configDir) {
     logName: "skill"
   });
 }
-async function loadAllSkills(configDir) {
+async function loadProjectSkills(projectDir) {
+  return loadItemsFromDir(getProjectSkillsDir(projectDir), {
+    extension: SKILL_EXTENSION,
+    logName: "skill"
+  });
+}
+async function loadAllSkills(configDir, projectDir) {
   const [defaultSkills, userSkills] = await Promise.all([loadDefaultSkills(), loadUserSkills(configDir)]);
   const skillMap = /* @__PURE__ */ new Map();
   for (const skill of defaultSkills) {
@@ -2788,14 +2852,20 @@ async function loadAllSkills(configDir) {
   for (const skill of userSkills) {
     skillMap.set(skill.metadata.id, skill);
   }
+  if (projectDir) {
+    const projectSkills = await loadProjectSkills(projectDir);
+    for (const skill of projectSkills) {
+      skillMap.set(skill.metadata.id, skill);
+    }
+  }
   return Array.from(skillMap.values());
 }
-async function getEnabledSkills(configDir) {
-  const all = await loadAllSkills(configDir);
+async function getEnabledSkills(configDir, projectDir) {
+  const all = await loadAllSkills(configDir, projectDir);
   return all.filter((s) => isSkillEnabled(s.metadata.id));
 }
-async function getEnabledSkillMetadata(configDir) {
-  const enabled = await getEnabledSkills(configDir);
+async function getEnabledSkillMetadata(configDir, projectDir) {
+  const enabled = await getEnabledSkills(configDir, projectDir);
   return enabled.map((s) => s.metadata);
 }
 function isSkillEnabled(skillId) {
@@ -2803,18 +2873,11 @@ function isSkillEnabled(skillId) {
   if (value === null) return true;
   return value === "true";
 }
-function setSkillEnabled(skillId, enabled) {
-  setSetting(`${SKILL_SETTING_PREFIX}${skillId}`, String(enabled));
-}
 async function getDefaultSkillIds() {
   const ids = await getDefaultIds(DEFAULTS_DIR2, SKILL_EXTENSION);
   if (ids.length) return ids;
   return getDefaultIds(DEFAULTS_DIR_ALT2, SKILL_EXTENSION);
 }
-async function getDefaultSkillContent(skillId) {
-  const defaults = await loadDefaultSkills();
-  return defaults.find((s) => s.metadata.id === skillId) ?? null;
-}
 async function isDefaultSkill(skillId) {
   const defaultIds = await getDefaultSkillIds();
   return defaultIds.includes(skillId);
@@ -2822,17 +2885,28 @@ async function isDefaultSkill(skillId) {
 function findSkillById(skillId, skills) {
   return skills.find((s) => s.metadata.id === skillId);
 }
-async function skillExists(configDir, skillId) {
-  return pathExists2(join5(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`));
+async function skillExists(configDir, skillId, projectDir) {
+  if (await pathExists(join5(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`))) return true;
+  if (projectDir && await pathExists(join5(getProjectSkillsDir(projectDir), `${skillId}${SKILL_EXTENSION}`)))
+    return true;
+  return false;
 }
 async function saveSkill(configDir, skill) {
   const skillsDir = getSkillsDir(configDir);
-  if (!await pathExists2(skillsDir)) {
-    await mkdir3(skillsDir, { recursive: true });
+  if (!await pathExists(skillsDir)) {
+    await mkdir4(skillsDir, { recursive: true });
   }
   const filePath = join5(skillsDir, `${skill.metadata.id}${SKILL_EXTENSION}`);
   const content = matter3.stringify(skill.prompt, skill.metadata);
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile5(filePath, content, "utf-8");
+}
+async function saveSkillToProject(projectDir, skill) {
+  await saveItemToDir(
+    getProjectSkillsDir(projectDir),
+    skill,
+    SKILL_EXTENSION,
+    (s) => matter3.stringify(s.prompt, s.metadata)
+  );
 }
 async function deleteSkill(configDir, skillId) {
   const isDefault = await isDefaultSkill(skillId);
@@ -2841,13 +2915,16 @@ async function deleteSkill(configDir, skillId) {
   }
   const filePath = join5(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`);
   try {
-    await unlink2(filePath);
+    await unlink3(filePath);
     deleteSetting(`${SKILL_SETTING_PREFIX}${skillId}`);
     return { success: true };
   } catch {
     return { success: false };
   }
 }
+async function deleteProjectSkill(projectDir, skillId) {
+  return deleteItemFromDir(getProjectSkillsDir(projectDir), skillId, SKILL_EXTENSION);
+}
 
 // src/server/chat/agent-loop.ts
 import stripAnsi from "strip-ansi";
@@ -3141,8 +3218,9 @@ async function runTopLevelAgentLoop(config, turnMetrics) {
       eventStore.append(sessionId, createFormatRetryEvent(formatRetryCount, MAX_FORMAT_RETRIES));
       requestMessages.push({ role: "user", content: FORMAT_CORRECTION_PROMPT2, source: "history" });
     }
-    const configDir = getGlobalConfigDir(getRuntimeConfig().mode ?? "production");
-    const skills = await getEnabledSkillMetadata(configDir);
+    const runtimeConfig = getRuntimeConfig();
+    const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
+    const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
     if (signal?.aborted) throw new Error("Aborted");
     const assembledRequest = config.assembleRequest({
       workdir: session.workdir,
@@ -3532,8 +3610,9 @@ async function executeSubAgent(options) {
   }
   const { content: instructionContent, files } = await getAllInstructions(session.workdir, session.projectId);
   const injectedFiles = toInjectedFiles(files);
-  const configDir = getGlobalConfigDir(getRuntimeConfig().mode ?? "production");
-  const skills = await getEnabledSkillMetadata(configDir);
+  const config = getRuntimeConfig();
+  const configDir = getGlobalConfigDir(config.mode ?? "production");
+  const skills = await getEnabledSkillMetadata(configDir, config.workdir);
   const systemPrompt = buildSubAgentSystemPrompt(
     session.workdir,
     agentDef,
@@ -3802,7 +3881,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ZBAAAOUH.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-NFFQWH6M.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3850,7 +3929,7 @@ var handler = async (args, _context, helpers) => {
   }
   const config = getRuntimeConfig();
   const configDir = getGlobalConfigDir(config.mode ?? "production");
-  const allSkills = await loadAllSkills(configDir);
+  const allSkills = await loadAllSkills(configDir, config.workdir);
   const skill = findSkillById(skillId, allSkills);
   if (!skill) {
     const available = allSkills.map((s) => s.metadata.id).join(", ");
@@ -4054,7 +4133,7 @@ var webFetchTool = createTool(
 
 // src/server/dev-server/manager.ts
 import { spawn as spawn3 } from "child_process";
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
 import { resolve as resolve5, join as join6 } from "path";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
@@ -4137,9 +4216,9 @@ var DevServerManager = class {
   async saveConfig(workdir, config) {
     const resolved = this.resolveWorkdir(workdir);
     const dirPath = join6(resolved, ".openfox");
-    await mkdir4(dirPath, { recursive: true });
+    await mkdir5(dirPath, { recursive: true });
     const configPath = getDevServerConfigPath(workdir);
-    await writeFile5(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    await writeFile6(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   }
   async start(workdir) {
     const instance = this.getInstance(workdir);
@@ -4839,7 +4918,7 @@ async function performContextCompaction(options) {
   const subAgentDefs = getSubAgents(allAgents);
   const toolRegistry = getToolRegistryForAgent(plannerDef);
   const configDir = getGlobalConfigDir(config.mode ?? "production");
-  const skills = await getEnabledSkillMetadata(configDir);
+  const skills = await getEnabledSkillMetadata(configDir, config.workdir);
   const assembledRequest = assembleAgentRequest({
     agentDef: plannerDef,
     subAgentDefs,
@@ -4942,12 +5021,21 @@ export {
   cancelPathConfirmationsForSession,
   checkAborted,
   spawnShellProcess,
+  pathExists,
+  getDefaultIds,
+  loadItemsFromDir,
+  saveItemToDir,
+  jsonSerializer,
+  deleteItemFromDir,
   loadDefaultAgents,
   loadUserAgents,
+  loadProjectAgents,
   loadAllAgents,
+  saveAgentToProject,
+  deleteProjectAgent,
   loadAllAgentsDefault,
   getDefaultAgentIds,
-  getDefaultAgentContent,
+  isDefaultAgent,
   findAgentById,
   getSubAgents,
   getTopLevelAgents,
@@ -4964,20 +5052,19 @@ export {
   createToolResultEvent,
   createChatDoneEvent,
   assembleAgentRequest,
-  pathExists2 as pathExists,
-  getDefaultIds,
-  loadItemsFromDir,
   loadDefaultSkills,
   loadUserSkills,
+  loadProjectSkills,
   loadAllSkills,
   isSkillEnabled,
-  setSkillEnabled,
   getDefaultSkillIds,
-  getDefaultSkillContent,
+  isDefaultSkill,
   findSkillById,
   skillExists,
   saveSkill,
+  saveSkillToProject,
   deleteSkill,
+  deleteProjectSkill,
   maybeAutoCompactContext,
   performManualContextCompaction,
   resolveCompactionStatsIdentity,
@@ -4993,4 +5080,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-CL2ZPJAG.js.map
+//# sourceMappingURL=chunk-ARJIHQ3S.js.map