openfox 2.0.58 → 2.0.60

package/dist/{chunk-LAWUUAN7.js → chunk-3JRYK5UG.js}

@@ -9,12 +9,12 @@ import {
   getSessionProcesses,
   startProcessCommand,
   stopProcess
-} from "./chunk-BIWVYBIE.js";
+} from "./chunk-BGTEIA2S.js";
 import {
   getMaxPerSession,
   getSessionProcessCount,
   terminateProcessTree
-} from "./chunk-ADOXTORQ.js";
+} from "./chunk-PK2RMVMB.js";
 import {
   createMcpTools
 } from "./chunk-NWO6GRYE.js";
@@ -32,8 +32,9 @@ import {
 import {
   SETTINGS_KEYS,
   deleteSetting,
-  getSetting
-} from "./chunk-CDRQJDSJ.js";
+  getSetting,
+  setSetting
+} from "./chunk-WNSAJCWT.js";
 import {
   getProject
 } from "./chunk-YQ3SOPBI.js";
@@ -73,7 +74,7 @@ import {
 import {
   loadGlobalConfig,
   saveGlobalConfig
-} from "./chunk-YMEZFRY2.js";
+} from "./chunk-43UFGATL.js";
 import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
@@ -222,6 +223,9 @@ async function isPathWithinSandbox(path, workdir, sessionId) {
 function looksLikeRegex(str) {
   return /[*?+[\]\\]/.test(str);
 }
+function isPlaceholderToken(str) {
+  return str.includes("__URL__") || str.includes("__FILEURL__") || str.includes("__SED__");
+}
 function extractAbsolutePathsFromCommand(command) {
   if (!command.trim()) {
     return [];
@@ -273,16 +277,13 @@ function extractAbsolutePathsFromCommand(command) {
       }
     }
   }
-  const absolutePattern = /(?:^|[\s=(])(\/?\/[a-zA-Z0-9_\-./]+)/g;
+  const absolutePattern = /(?:^|[\s=(])(\/[^\s"'|&;<>`()]+)/g;
   while ((match = absolutePattern.exec(sanitized)) !== null) {
-    const pathCandidate = match[1];
-    if (pathCandidate.includes("__URL__") || pathCandidate.includes("__FILEURL__")) {
-      continue;
-    }
-    if (looksLikeRegex(pathCandidate)) {
-      continue;
-    }
-    const resolved = normalize(pathCandidate);
+    const candidate = match[1];
+    if (isPlaceholderToken(candidate)) continue;
+    if (looksLikeRegex(candidate)) continue;
+    const resolved = normalize(candidate);
+    if (resolved === "/" || resolved === "") continue;
     if (!isSafePath(resolved)) {
       paths.push(resolved);
     }
@@ -1330,6 +1331,7 @@ function spawnShellProcess(command, cwd, _signal, detached = false) {
     cwd,
     env: { ...process.env, FORCE_COLOR: "0" },
     stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
     ...detached ? { detached: true } : {}
   });
 }
@@ -1667,6 +1669,10 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
   }
 );
 
+// src/server/sub-agents/manager.ts
+import { readFile as readFile8, access as access4 } from "fs/promises";
+import { join as join7, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
+
 // src/server/agents/registry.ts
 import { readdir as readdir3, readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3, access as access2, unlink as unlink2 } from "fs/promises";
 import { join as join4, dirname as dirname2 } from "path";
@@ -2029,62 +2035,173 @@ async function fileExists(path) {
 }
 
 // src/server/skills/registry.ts
-import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3 } from "fs/promises";
+import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3, readdir as readdir4, readFile as readFile7, realpath as realpath2, rm } from "fs/promises";
 import { join as join6, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { homedir as homedir2 } from "os";
 import matter3 from "gray-matter";
 var __bundleDir2 = dirname4(fileURLToPath2(import.meta.url));
 var DEFAULTS_DIR2 = join6(__bundleDir2, "defaults");
 var DEFAULTS_DIR_ALT2 = join6(__bundleDir2, "skill-defaults");
 var SKILL_EXTENSION = ".skill.md";
 var SKILL_SETTING_PREFIX = "skill.enabled.";
+var PORTABLE_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function getSkillsDir(configDir) {
   return join6(configDir, "skills");
 }
 function getProjectSkillsDir(projectDir) {
   return join6(projectDir, ".openfox", "skills");
 }
-async function loadDefaultSkills() {
-  let defaults = await loadItemsFromDir(DEFAULTS_DIR2, {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
-  if (!defaults.length) {
-    defaults = await loadItemsFromDir(DEFAULTS_DIR_ALT2, {
-      extension: SKILL_EXTENSION,
-      logName: "skill"
-    });
+function portableDisplayName(data, id) {
+  const metadata = data["metadata"];
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return id;
+  const openfox = metadata["openfox"];
+  if (!openfox || typeof openfox !== "object" || Array.isArray(openfox)) return id;
+  const displayName = openfox["displayName"];
+  return typeof displayName === "string" && displayName.trim() ? displayName : id;
+}
+function portableVersion(data) {
+  const metadata = data["metadata"];
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+    const version = metadata["version"];
+    if (version !== void 0) return String(version);
   }
-  return defaults;
+  return data["version"] === void 0 ? "" : String(data["version"]);
+}
+async function loadPortableSkills(dir, source) {
+  let entries;
+  try {
+    entries = await readdir4(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const packageDir = join6(dir, entry.name);
+    const entrypoint = join6(packageDir, "SKILL.md");
+    try {
+      const content = await readFile7(entrypoint, "utf-8");
+      const parsed = matter3(content);
+      const data = parsed.data;
+      const id = typeof data["name"] === "string" ? data["name"].trim() : "";
+      const description = typeof data["description"] === "string" ? data["description"].trim() : "";
+      const prompt = parsed.content.trim();
+      if (!id || !description || !prompt) continue;
+      const resolvedDirectory = await realpath2(packageDir);
+      const warnings = [];
+      if (id.length > 64 || !PORTABLE_NAME_REGEX.test(id)) {
+        warnings.push("Skill name must use 1-64 lowercase letters, numbers, and single hyphens");
+      }
+      if (id !== entry.name) {
+        warnings.push(`Skill name "${id}" does not match package directory "${entry.name}"`);
+      }
+      skills.push({
+        metadata: {
+          id,
+          name: portableDisplayName(data, id),
+          description,
+          version: portableVersion(data)
+        },
+        prompt,
+        rawMetadata: data,
+        entrypoint,
+        directory: resolvedDirectory,
+        source,
+        legacy: false,
+        warnings
+      });
+    } catch {
+    }
+  }
+  return skills;
+}
+async function annotateLegacySkills(skills, dir, source) {
+  return Promise.all(
+    skills.map(async (skill) => {
+      const entrypoint = join6(dir, `${skill.metadata.id}${SKILL_EXTENSION}`);
+      let resolvedEntrypoint = entrypoint;
+      try {
+        resolvedEntrypoint = await realpath2(entrypoint);
+      } catch {
+      }
+      return {
+        ...skill,
+        rawMetadata: { ...skill.metadata },
+        entrypoint: resolvedEntrypoint,
+        directory: dirname4(resolvedEntrypoint),
+        source,
+        legacy: true,
+        warnings: ["Legacy .skill.md format"]
+      };
+    })
+  );
+}
+async function loadSkillsDirectory(dir, source) {
+  const [legacyRaw, portable] = await Promise.all([
+    loadItemsFromDir(dir, { extension: SKILL_EXTENSION, logName: "skill" }),
+    loadPortableSkills(dir, source)
+  ]);
+  const legacy = await annotateLegacySkills(legacyRaw, dir, source);
+  const merged = new Map(legacy.map((skill) => [skill.metadata.id, skill]));
+  for (const skill of portable) merged.set(skill.metadata.id, skill);
+  return [...merged.values()];
+}
+function getSelectedSkillDirectories() {
+  const raw = getSetting("skills.directories");
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+async function loadDefaultSkills() {
+  const defaults = await loadSkillsDirectory(DEFAULTS_DIR2, "bundled");
+  if (defaults.length) return defaults;
+  return loadSkillsDirectory(DEFAULTS_DIR_ALT2, "bundled");
 }
 async function loadUserSkills(configDir) {
-  return loadItemsFromDir(getSkillsDir(configDir), {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
+  return loadSkillsDirectory(getSkillsDir(configDir), "global-openfox");
 }
 async function loadProjectSkills(projectDir) {
-  return loadItemsFromDir(getProjectSkillsDir(projectDir), {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
+  return loadSkillsDirectory(getProjectSkillsDir(projectDir), "project-openfox");
 }
-async function loadAllSkills(configDir, projectDir) {
-  const [defaultSkills, userSkills] = await Promise.all([loadDefaultSkills(), loadUserSkills(configDir)]);
+async function loadAllSkills(configDir, projectDir, options = {}) {
+  return (await loadAllSkillsWithDiagnostics(configDir, projectDir, options)).skills;
+}
+async function loadAllSkillsWithDiagnostics(configDir, projectDir, options = {}) {
+  const home = options.homeDir ?? homedir2();
+  const selected = (options.selectedDirectories ?? getSelectedSkillDirectories()).map(
+    (dir) => dir === "~" ? home : dir.startsWith("~/") ? join6(home, dir.slice(2)) : dir
+  );
+  const locations = [
+    loadDefaultSkills(),
+    loadSkillsDirectory(join6(home, ".agents", "skills"), "global-shared"),
+    loadUserSkills(configDir),
+    ...selected.map((dir) => loadSkillsDirectory(dir, "selected")),
+    ...projectDir ? [loadSkillsDirectory(join6(projectDir, ".agents", "skills"), "project-shared"), loadProjectSkills(projectDir)] : []
+  ];
+  const groups = await Promise.all(locations);
   const skillMap = /* @__PURE__ */ new Map();
-  for (const skill of defaultSkills) {
-    skillMap.set(skill.metadata.id, skill);
-  }
-  for (const skill of userSkills) {
-    skillMap.set(skill.metadata.id, skill);
-  }
-  if (projectDir) {
-    const projectSkills = await loadProjectSkills(projectDir);
-    for (const skill of projectSkills) {
+  const diagnostics = [];
+  for (const group of groups) {
+    for (const skill of group) {
+      const previous = skillMap.get(skill.metadata.id);
+      if (previous) {
+        if (previous.directory === skill.directory && previous.legacy === skill.legacy) {
+          diagnostics.push(`Skill "${skill.metadata.id}" reached through multiple paths`);
+        } else {
+          diagnostics.push(
+            `Skill "${skill.metadata.id}" from ${skill.source ?? "unknown"} overrides ${previous.source ?? "unknown"}`
+          );
+        }
+      }
       skillMap.set(skill.metadata.id, skill);
     }
   }
-  return Array.from(skillMap.values());
+  return { skills: Array.from(skillMap.values()), diagnostics };
 }
 async function getEnabledSkills(configDir, projectDir) {
   const all = await loadAllSkills(configDir, projectDir);
@@ -2099,10 +2216,12 @@ 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);
+  const defaults = await loadDefaultSkills();
+  return defaults.map((s) => s.metadata.id);
 }
 async function isDefaultSkill(skillId) {
   const defaultIds = await getDefaultSkillIds();
@@ -2113,26 +2232,104 @@ function findSkillById(skillId, skills) {
 }
 async function skillExists(configDir, skillId, projectDir) {
   if (await pathExists(join6(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`))) return true;
+  if (await pathExists(join6(getSkillsDir(configDir), skillId, "SKILL.md"))) return true;
   if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), `${skillId}${SKILL_EXTENSION}`)))
     return true;
+  if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), skillId, "SKILL.md"))) return true;
   return false;
 }
-async function saveSkill(configDir, skill) {
-  const skillsDir = getSkillsDir(configDir);
-  if (!await pathExists(skillsDir)) {
-    await mkdir4(skillsDir, { recursive: true });
+function portableFrontmatter(skill) {
+  const metadata = {};
+  if (skill.metadata.version) metadata["version"] = skill.metadata.version;
+  if (skill.metadata.name !== skill.metadata.id) {
+    metadata["openfox"] = { displayName: skill.metadata.name };
   }
-  const filePath = join6(skillsDir, `${skill.metadata.id}${SKILL_EXTENSION}`);
-  const content = matter3.stringify(skill.prompt, skill.metadata);
-  await writeFile5(filePath, content, "utf-8");
+  return {
+    name: skill.metadata.id,
+    description: skill.metadata.description,
+    ...Object.keys(metadata).length ? { metadata } : {}
+  };
+}
+async function savePortableSkill(dir, skill) {
+  const packageDir = join6(dir, skill.metadata.id);
+  await mkdir4(packageDir, { recursive: true });
+  await writeFile5(join6(packageDir, "SKILL.md"), matter3.stringify(skill.prompt, portableFrontmatter(skill)), "utf-8");
+}
+async function saveSkill(configDir, skill) {
+  await savePortableSkill(getSkillsDir(configDir), skill);
 }
 async function saveSkillToProject(projectDir, skill) {
-  await saveItemToDir(
-    getProjectSkillsDir(projectDir),
-    skill,
-    SKILL_EXTENSION,
-    (s) => matter3.stringify(s.prompt, s.metadata)
-  );
+  await savePortableSkill(getProjectSkillsDir(projectDir), skill);
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function updatedPortableFrontmatter(existing, metadata) {
+  const frontmatter = { ...existing.rawMetadata ?? {} };
+  const portableMetadata = { ...asRecord(frontmatter["metadata"]) };
+  const openfox = { ...asRecord(portableMetadata["openfox"]) };
+  frontmatter["name"] = existing.metadata.id;
+  frontmatter["description"] = metadata.description;
+  if (metadata.version) portableMetadata["version"] = metadata.version;
+  else delete portableMetadata["version"];
+  if (metadata.name !== existing.metadata.id) openfox["displayName"] = metadata.name;
+  else delete openfox["displayName"];
+  if (Object.keys(openfox).length) portableMetadata["openfox"] = openfox;
+  else delete portableMetadata["openfox"];
+  if (Object.keys(portableMetadata).length) frontmatter["metadata"] = portableMetadata;
+  else delete frontmatter["metadata"];
+  return frontmatter;
+}
+function canModifySkill(existing) {
+  if (existing.source === "global-openfox" || existing.source === "project-openfox") return true;
+  return !existing.legacy && (existing.source === "global-shared" || existing.source === "selected" || existing.source === "project-shared");
+}
+async function updateOwnedSkill(existing, changes) {
+  if (!existing.entrypoint || !canModifySkill(existing)) return null;
+  const normalizedMetadata = {
+    ...existing.metadata,
+    ...changes.metadata ?? {},
+    id: existing.metadata.id
+  };
+  if (!existing.legacy) {
+    const frontmatter = updatedPortableFrontmatter(existing, normalizedMetadata);
+    const updated2 = {
+      ...existing,
+      ...changes,
+      metadata: normalizedMetadata,
+      rawMetadata: frontmatter,
+      prompt: changes.prompt ?? existing.prompt
+    };
+    await writeFile5(existing.entrypoint, matter3.stringify(updated2.prompt, frontmatter), "utf-8");
+    return updated2;
+  }
+  const metadata = {
+    ...existing.rawMetadata ?? existing.metadata,
+    ...changes.metadata ?? {},
+    id: existing.metadata.id
+  };
+  const updated = {
+    ...existing,
+    ...changes,
+    metadata,
+    rawMetadata: metadata,
+    prompt: changes.prompt ?? existing.prompt
+  };
+  await writeFile5(existing.entrypoint, matter3.stringify(updated.prompt, metadata), "utf-8");
+  return updated;
+}
+async function deleteOwnedSkill(existing) {
+  if (!existing.entrypoint || !canModifySkill(existing)) {
+    return { success: false, reason: "This skill is read-only" };
+  }
+  try {
+    if (existing.legacy) await unlink3(existing.entrypoint);
+    else await rm(dirname4(existing.entrypoint), { recursive: true });
+    deleteSetting(`${SKILL_SETTING_PREFIX}${existing.metadata.id}`);
+    return { success: true };
+  } catch {
+    return { success: false, reason: "Cannot delete this skill" };
+  }
 }
 async function deleteSkill(configDir, skillId) {
   const isDefault = await isDefaultSkill(skillId);
@@ -2910,7 +3107,7 @@ async function describeImageFromDataUrl(dataUrl, visionModel, options) {
 import { createHash as createHash2 } from "crypto";
 async function loadVisionModelFromGlobalConfig() {
   try {
-    const { loadGlobalConfig: loadGlobalConfig2, getVisionFallback } = await import("./config-C2YDEF3N.js");
+    const { loadGlobalConfig: loadGlobalConfig2, getVisionFallback } = await import("./config-GMQUPNBY.js");
     const runtimeConfig = getRuntimeConfig();
     const mode = runtimeConfig.mode ?? "production";
     const globalConfig = await loadGlobalConfig2(mode);
@@ -3246,6 +3443,33 @@ function getWindowOptions(sessionId) {
   const id = getCurrentContextWindowId(sessionId);
   return id ? { contextWindowId: id } : void 0;
 }
+async function loadGitIgnoreRules(workdir) {
+  if (!isAbsolute3(workdir)) return "";
+  let currentDir = workdir;
+  while (true) {
+    const gitignorePath = join7(currentDir, ".gitignore");
+    try {
+      await access4(gitignorePath);
+      const content = await readFile8(gitignorePath, "utf-8");
+      const trimmed = content.trim();
+      if (!trimmed) return "";
+      const lines = trimmed.split("\n");
+      const capped = lines.slice(0, 100);
+      if (capped.length < lines.length) capped.push("# ... truncated (too many patterns)");
+      const final = capped.join("\n").slice(0, 4096);
+      return `## Repository Exclusion Rules (.gitignore)
+
+The following patterns from \`.gitignore\` should be excluded from file searches:
+
+${final}`;
+    } catch {
+    }
+    const parentDir = dirname5(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return "";
+}
 async function executeSubAgent(options) {
   const {
     subAgentType,
@@ -3317,7 +3541,9 @@ async function executeSubAgent(options) {
   const config = getRuntimeConfig();
   const configDir = getGlobalConfigDir(config.mode ?? "production");
   const skills = await getEnabledSkillMetadata(configDir, config.workdir);
-  const systemPrompt = buildBasePrompt(session.workdir, void 0, skills.length > 0 ? skills : void 0, llmClient.getModel()) + "\n\n" + agentDef.prompt + RETURN_VALUE_INSTRUCTION;
+  const hasRunCommand = agentDef.metadata.allowedTools?.includes("run_command") ?? false;
+  const gitignoreSection = hasRunCommand ? await loadGitIgnoreRules(session.workdir) : "";
+  const systemPrompt = buildBasePrompt(session.workdir, void 0, skills.length > 0 ? skills : void 0, llmClient.getModel()) + "\n\n" + agentDef.prompt + (gitignoreSection ? "\n\n" + gitignoreSection : "") + RETURN_VALUE_INSTRUCTION;
   const subAgentScope = { type: "subagent", sessionId, subAgentId, subAgentType };
   const loopResult = await runTopLevelAgentLoop(
     {
@@ -3425,7 +3651,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-YJLXW3QS.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-WGAZKL56.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3463,6 +3689,13 @@ var callSubAgentTool = {
 };
 
 // src/server/tools/load-skill.ts
+function formatSkillPrompt(skill) {
+  if (skill.legacy !== false || !skill.directory) return skill.prompt;
+  return `Skill package directory: ${skill.directory}
+Resolve relative paths in these instructions from that directory.
+
+${skill.prompt}`;
+}
 var handler = async (args, _context, helpers) => {
   const { skillId } = args;
   if (!skillId) {
@@ -3479,7 +3712,7 @@ var handler = async (args, _context, helpers) => {
     const available = allSkills.map((s) => s.metadata.id).join(", ");
     return helpers.error(`Skill "${skillId}" not found. Available skills: ${available}`);
   }
-  return helpers.success(skill.prompt);
+  return helpers.success(formatSkillPrompt(skill));
 };
 var loadSkillTool = createTool(
   "load_skill",
@@ -3676,13 +3909,13 @@ var webFetchTool = createTool(
 
 // src/server/dev-server/manager.ts
 import { spawn as spawn2 } from "child_process";
-import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { resolve as resolve5, join as join7 } from "path";
+import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { resolve as resolve5, join as join8 } from "path";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
 var getDevServerConfigPath = (workdir) => {
   const mode = getRuntimeConfig().mode ?? "production";
-  return join7(resolve5(workdir), ".openfox", `${mode === "development" ? "dev-dev" : "dev"}.json`);
+  return join8(resolve5(workdir), ".openfox", `${mode === "development" ? "dev-dev" : "dev"}.json`);
 };
 var ERROR_PATTERNS = [
   /EADDRINUSE/,
@@ -3743,7 +3976,7 @@ var DevServerManager = class {
   async loadConfig(workdir) {
     try {
       const configPath = getDevServerConfigPath(workdir);
-      const raw = await readFile7(configPath, "utf-8");
+      const raw = await readFile9(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed.command || !parsed.url) return null;
       return {
@@ -3758,7 +3991,7 @@ var DevServerManager = class {
   }
   async saveConfig(workdir, config) {
     const resolved = this.resolveWorkdir(workdir);
-    const dirPath = join7(resolved, ".openfox");
+    const dirPath = join8(resolved, ".openfox");
     await mkdir5(dirPath, { recursive: true });
     const configPath = getDevServerConfigPath(workdir);
     await writeFile6(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
@@ -3793,7 +4026,8 @@ var DevServerManager = class {
       cwd: resolved,
       env: { ...process.env, FORCE_COLOR: "1" },
       stdio: ["ignore", "pipe", "pipe"],
-      detached: true
+      detached: true,
+      windowsHide: true
     });
     instance.process = proc;
     const appendLog = (stream, content) => {
@@ -4241,7 +4475,7 @@ function resolveAgentDef2(sessionManager, sessionId) {
 }
 async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-YJLXW3QS.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-WGAZKL56.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   const allAgents = await loadAllAgentsDefault();
@@ -4254,7 +4488,7 @@ async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
 async function computeSessionHash(sessionManager, sessionId) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
   const agentDef = await resolveAgentDef2(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-YJLXW3QS.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-WGAZKL56.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   return computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -4273,6 +4507,7 @@ async function applyDynamicContext(sessionManager, sessionId) {
 // src/server/tools/mcp-config.ts
 var mcpManagerForTools = null;
 var mcpConfigMode = "production";
+var mcpConfigPath;
 var mcpNotifyChanged = null;
 function setMcpManagerForTools(manager) {
   mcpManagerForTools = manager;
@@ -4280,6 +4515,9 @@ function setMcpManagerForTools(manager) {
 function setMcpConfigMode(mode) {
   mcpConfigMode = mode;
 }
+function setMcpConfigPath(path) {
+  mcpConfigPath = path;
+}
 function setNotifyMcpServersChanged(fn) {
   mcpNotifyChanged = fn;
 }
@@ -4355,13 +4593,13 @@ var mcpConfigTool = createTool(
       return helpers.error("MCP manager not available");
     }
     async function persistAndRebuild(updater) {
-      const globalConfig = await loadGlobalConfig(mcpConfigMode);
+      const globalConfig = await loadGlobalConfig(mcpConfigMode, mcpConfigPath);
       const mcpServers = { ...globalConfig.mcpServers ?? {} };
       const updated = updater(mcpServers);
-      await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated });
+      await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated }, mcpConfigPath);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-YJLXW3QS.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-WGAZKL56.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4463,7 +4701,7 @@ var mcpConfigTool = createTool(
 );
 
 // src/server/tools/trace-code.ts
-import { stat as stat2, readFile as readFile8 } from "fs/promises";
+import { stat as stat2, readFile as readFile10 } from "fs/promises";
 function graphNode(location, depth, relation, symbolName, symbolKind) {
   const node = { location, depth, relation, symbolName };
   if (symbolKind) node.symbolKind = symbolKind;
@@ -4495,7 +4733,7 @@ async function getCachedLines(path, approvedPaths) {
   }
   try {
     const stats = await stat2(path);
-    const content = await readFile8(path, "utf-8");
+    const content = await readFile10(path, "utf-8");
     const lines = content.split("\n");
     fileCache.set(path, { mtimeMs: stats.mtimeMs, lines });
     if (fileCache.size > CACHE_MAX_SIZE) {
@@ -4997,14 +5235,18 @@ export {
   loadUserSkills,
   loadProjectSkills,
   loadAllSkills,
+  loadAllSkillsWithDiagnostics,
   getEnabledSkillMetadata,
   isSkillEnabled,
+  setSkillEnabled,
   getDefaultSkillIds,
   isDefaultSkill,
   findSkillById,
   skillExists,
   saveSkill,
   saveSkillToProject,
+  updateOwnedSkill,
+  deleteOwnedSkill,
   deleteSkill,
   deleteProjectSkill,
   runTopLevelAgentLoop,
@@ -5021,6 +5263,7 @@ export {
   applyDynamicContext,
   setMcpManagerForTools,
   setMcpConfigMode,
+  setMcpConfigPath,
   setNotifyMcpServersChanged,
   parseToolPermissions,
   getToolPermissions,
@@ -5031,4 +5274,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-LAWUUAN7.js.map
+//# sourceMappingURL=chunk-3JRYK5UG.js.map

package/dist/{chunk-YMEZFRY2.js → chunk-43UFGATL.js}

@@ -125,8 +125,8 @@ var configSchema = z.object({
 function getVisionFallback(config) {
   return config.visionFallback ?? getDefaultVisionFallback();
 }
-async function loadGlobalConfig(mode) {
-  const configPath = getGlobalConfigPath(mode);
+async function loadGlobalConfig(mode, configPathOverride) {
+  const configPath = configPathOverride ?? getGlobalConfigPath(mode);
   try {
     const content = await readFile(configPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -138,8 +138,8 @@ async function loadGlobalConfig(mode) {
 function getDefaultVisionFallback() {
   return { enabled: false, url: "http://localhost:11434", model: "qwen3.5:0.8b", timeout: 120 };
 }
-async function saveGlobalConfig(mode, config) {
-  const configPath = getGlobalConfigPath(mode);
+async function saveGlobalConfig(mode, config, configPathOverride) {
+  const configPath = configPathOverride ?? getGlobalConfigPath(mode);
   const fullConfig = {
     providers: config.providers ?? [],
     mcpServers: config.mcpServers,
@@ -291,4 +291,4 @@ export {
   removeProvider,
   activateProvider
 };
-//# sourceMappingURL=chunk-YMEZFRY2.js.map
+//# sourceMappingURL=chunk-43UFGATL.js.map