openfox 1.6.15 → 1.6.16

package/dist/{chunk-G4E72ST3.js → chunk-NN65D5SI.js}

@@ -6,7 +6,7 @@ import {
   createVerifierNudgeConfig,
   runBuilderTurn,
   runChatTurn
-} from "./chunk-YM6VHAPM.js";
+} from "./chunk-U54QVKL2.js";
 import {
   TurnMetrics,
   agentExists,
@@ -17,46 +17,34 @@ import {
   createMessageStartEvent,
   createToolRegistry,
   deleteAgent,
-  deleteItem,
   deleteSkill,
   devServerManager,
-  dirExists,
-  ensureDefaultAgents,
-  ensureDefaultSkills,
-  ensureDir,
   executeSubAgent,
   findAgentById,
-  findById,
-  findModifiedDefaultFiles,
   findSkillById,
   getAllInstructions,
-  getBundleDir,
+  getDefaultAgentContent,
   getDefaultAgentIds,
-  getDefaultIds,
+  getDefaultSkillContent,
   getDefaultSkillIds,
   getEnabledSkillMetadata,
-  getModifiedDefaultAgentIds,
-  getModifiedDefaultSkillIds,
   getToolRegistryForAgent,
   isSkillEnabled,
   loadAllAgents,
   loadAllAgentsDefault,
   loadAllSkills,
-  loadItems,
+  loadDefaultAgents,
+  loadDefaultSkills,
+  loadUserAgents,
+  loadUserSkills,
   maybeAutoCompactContext,
   performManualContextCompaction,
-  restoreAllDefaultAgents,
-  restoreAllDefaultSkills,
-  restoreDefault,
-  restoreDefaultAgent,
-  restoreDefaultSkill,
   saveAgent,
-  saveItem,
   saveSkill,
   setSkillEnabled,
   skillExists,
   spawnShellProcess
-} from "./chunk-3WHZ47PY.js";
+} from "./chunk-4OI4VPZ6.js";
 import {
   getPathSeparator,
   getPlatformShell,
@@ -156,9 +144,9 @@ import {
 import express from "express";
 import cors from "cors";
 import { createServer as createHttpServer } from "http";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname4, resolve, join as join5 } from "path";
-import { readFile as readFile3 } from "fs/promises";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname5, resolve, join as join6 } from "path";
+import { readFile as readFile4 } from "fs/promises";
 import { createServer as createViteServer } from "vite";
 
 // src/server/llm/mock.ts
@@ -1426,7 +1414,7 @@ function unsubscribeAllFromTerminal(ws) {
 }
 
 // src/server/workflows/registry.ts
-import { readdir, readFile, writeFile, copyFile, mkdir, access, unlink } from "fs/promises";
+import { readdir, readFile, writeFile, mkdir, access, unlink } from "fs/promises";
 import { join, dirname } from "path";
 import { constants } from "fs";
 import { fileURLToPath } from "url";
@@ -1445,49 +1433,20 @@ async function pathExists(path) {
     return false;
   }
 }
-async function ensureDefaultWorkflows(configDir) {
-  const workflowsDir = getWorkflowsDir(configDir);
-  if (!await pathExists(workflowsDir)) {
-    await mkdir(workflowsDir, { recursive: true });
-  }
-  let defaultFiles;
-  let sourceDir;
-  try {
-    defaultFiles = (await readdir(DEFAULTS_DIR)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
-    sourceDir = DEFAULTS_DIR;
-  } catch {
-    try {
-      defaultFiles = (await readdir(DEFAULTS_DIR_ALT)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
-      sourceDir = DEFAULTS_DIR_ALT;
-    } catch {
-      logger.warn("No bundled workflow defaults found", { dir: DEFAULTS_DIR });
-      return;
-    }
-  }
-  for (const file of defaultFiles) {
-    const targetPath = join(workflowsDir, file);
-    try {
-      await copyFile(join(sourceDir, file), targetPath);
-    } catch (err) {
-      logger.error("Failed to copy default workflow", { file, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-}
-async function loadAllWorkflows(configDir) {
-  const workflowsDir = getWorkflowsDir(configDir);
-  if (!await pathExists(workflowsDir)) {
+async function loadWorkflowsFromDir(dir) {
+  if (!await pathExists(dir)) {
     return [];
   }
   let files;
   try {
-    files = (await readdir(workflowsDir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+    files = (await readdir(dir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
   } catch {
     return [];
   }
   const workflows = [];
   for (const file of files) {
     try {
-      const raw = await readFile(join(workflowsDir, file), "utf-8");
+      const raw = await readFile(join(dir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.metadata?.id && parsed.steps?.length > 0) {
         workflows.push(parsed);
@@ -1500,6 +1459,30 @@ async function loadAllWorkflows(configDir) {
   }
   return workflows;
 }
+async function loadDefaultWorkflows() {
+  let defaults = await loadWorkflowsFromDir(DEFAULTS_DIR);
+  if (!defaults.length) {
+    defaults = await loadWorkflowsFromDir(DEFAULTS_DIR_ALT);
+  }
+  return defaults;
+}
+async function loadUserWorkflows(configDir) {
+  return loadWorkflowsFromDir(getWorkflowsDir(configDir));
+}
+async function loadAllWorkflows(configDir) {
+  const [defaultWorkflows, userWorkflows] = await Promise.all([
+    loadDefaultWorkflows(),
+    loadUserWorkflows(configDir)
+  ]);
+  const workflowMap = /* @__PURE__ */ new Map();
+  for (const workflow of defaultWorkflows) {
+    workflowMap.set(workflow.metadata.id, workflow);
+  }
+  for (const workflow of userWorkflows) {
+    workflowMap.set(workflow.metadata.id, workflow);
+  }
+  return Array.from(workflowMap.values());
+}
 async function getDefaultWorkflowIds() {
   for (const dir of [DEFAULTS_DIR, DEFAULTS_DIR_ALT]) {
     try {
@@ -1510,33 +1493,13 @@ async function getDefaultWorkflowIds() {
   }
   return [];
 }
-async function restoreDefaultWorkflow(configDir, workflowId) {
-  const filename = `${workflowId}${WORKFLOW_EXTENSION}`;
-  for (const dir of [DEFAULTS_DIR, DEFAULTS_DIR_ALT]) {
-    const sourcePath = join(dir, filename);
-    if (await pathExists(sourcePath)) {
-      const targetPath = join(getWorkflowsDir(configDir), filename);
-      await copyFile(sourcePath, targetPath);
-      return true;
-    }
-  }
-  return false;
-}
-async function getModifiedDefaultWorkflowIds(configDir) {
-  return findModifiedDefaultFiles(
-    await getDefaultWorkflowIds(),
-    WORKFLOW_EXTENSION,
-    [DEFAULTS_DIR, DEFAULTS_DIR_ALT],
-    getWorkflowsDir(configDir)
-  );
+async function getDefaultWorkflowContent(workflowId) {
+  const defaults = await loadDefaultWorkflows();
+  return defaults.find((w) => w.metadata.id === workflowId) ?? null;
 }
-async function restoreAllDefaultWorkflows(configDir) {
-  const ids = await getDefaultWorkflowIds();
-  let count = 0;
-  for (const id of ids) {
-    if (await restoreDefaultWorkflow(configDir, id)) count++;
-  }
-  return count;
+async function isDefaultWorkflow(workflowId) {
+  const defaultIds = await getDefaultWorkflowIds();
+  return defaultIds.includes(workflowId);
 }
 function findWorkflowById(workflowId, workflows) {
   return workflows.find((p) => p.metadata.id === workflowId);
@@ -1554,12 +1517,16 @@ async function saveWorkflow(configDir, workflow) {
   await writeFile(filePath, JSON.stringify(workflow, null, 2) + "\n", "utf-8");
 }
 async function deleteWorkflow(configDir, workflowId) {
+  const isDefault = await isDefaultWorkflow(workflowId);
+  if (isDefault) {
+    return { success: false, reason: "Cannot delete built-in defaults" };
+  }
   const filePath = join(getWorkflowsDir(configDir), `${workflowId}${WORKFLOW_EXTENSION}`);
   try {
     await unlink(filePath);
-    return true;
+    return { success: true };
   } catch {
-    return false;
+    return { success: false };
   }
 }
 
@@ -4898,102 +4865,47 @@ ${summary}`,
   }
 };
 
-// src/server/commands/registry.ts
-import { readdir as readdir2 } from "fs/promises";
-import { join as join4 } from "path";
-var DEFAULTS_DIR2 = "defaults";
-var DEFAULTS_DIR_ALT2 = "command-defaults";
-var COMMAND_EXTENSION = ".command.md";
-function getCommandsDir(configDir) {
-  return join4(configDir, "commands");
-}
-async function ensureDefaultCommands(configDir) {
-  const bundleDir = getBundleDir();
-  const commandsDir = getCommandsDir(configDir);
-  await ensureDir(commandsDir);
-  const ids = await getDefaultIds(bundleDir, DEFAULTS_DIR2, COMMAND_EXTENSION);
-  for (const id of ids) {
-    if (!await restoreDefault(commandsDir, bundleDir, DEFAULTS_DIR2, id, COMMAND_EXTENSION)) {
-      await restoreDefault(commandsDir, bundleDir, DEFAULTS_DIR_ALT2, id, COMMAND_EXTENSION);
-    }
-  }
-}
-async function loadAllCommands(configDir) {
-  return loadItems(getCommandsDir(configDir), COMMAND_EXTENSION);
-}
-async function getDefaultCommandIds() {
-  const bundleDir = getBundleDir();
-  const ids = await getDefaultIds(bundleDir, DEFAULTS_DIR2, COMMAND_EXTENSION);
-  if (ids.length) return ids;
-  return getDefaultIds(bundleDir, DEFAULTS_DIR_ALT2, COMMAND_EXTENSION);
-}
-async function restoreDefaultCommand(configDir, commandId) {
-  const bundleDir = getBundleDir();
-  const commandsDir = getCommandsDir(configDir);
-  return restoreDefault(commandsDir, bundleDir, DEFAULTS_DIR2, commandId, COMMAND_EXTENSION) || restoreDefault(commandsDir, bundleDir, DEFAULTS_DIR_ALT2, commandId, COMMAND_EXTENSION);
-}
-async function getModifiedDefaultCommandIds(configDir) {
-  const bundleDir = getBundleDir();
-  const ids = await getDefaultCommandIds();
-  const files = (await readdir2(join4(bundleDir, DEFAULTS_DIR2))).filter((f) => f.endsWith(COMMAND_EXTENSION));
-  return files.map((f) => f.replace(COMMAND_EXTENSION, "")).filter((id) => ids.includes(id));
-}
-async function restoreAllDefaultCommands(configDir) {
-  const ids = await getDefaultCommandIds();
-  let count = 0;
-  for (const id of ids) {
-    if (await restoreDefaultCommand(configDir, id)) count++;
-  }
-  return count;
-}
-function findCommandById(commandId, commands) {
-  return findById(commandId, commands);
-}
-async function commandExists(configDir, commandId) {
-  return dirExists(join4(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`));
-}
-async function saveCommand(configDir, command) {
-  return saveItem(getCommandsDir(configDir), command.metadata.id, COMMAND_EXTENSION, command);
-}
-async function deleteCommand(configDir, commandId) {
-  return deleteItem(getCommandsDir(configDir), commandId, COMMAND_EXTENSION);
+// src/server/routes/skills.ts
+import { Router } from "express";
+
+// src/server/routes/crud-helpers.ts
+function computeOverrideIds(defaults, userItems) {
+  return userItems.filter((u) => defaults.some((d) => d.metadata.id === u.metadata.id)).map((u) => u.metadata.id);
 }
 
 // src/server/routes/skills.ts
-import { Router } from "express";
 function createSkillRoutes(configDir) {
   const router = Router();
   router.get("/", async (_req, res) => {
-    const [skills, defaultIds, modifiedIds] = await Promise.all([
-      loadAllSkills(configDir),
-      getDefaultSkillIds(),
-      getModifiedDefaultSkillIds(configDir)
+    const [defaults, userItems] = await Promise.all([
+      loadDefaultSkills(),
+      loadUserSkills(configDir)
     ]);
+    const overrideIds = computeOverrideIds(defaults, userItems);
     res.json({
-      skills: skills.map((s) => ({
+      defaults: defaults.map((s) => ({
+        ...s.metadata,
+        enabled: isSkillEnabled(s.metadata.id)
+      })),
+      userItems: userItems.map((s) => ({
         ...s.metadata,
         enabled: isSkillEnabled(s.metadata.id)
       })),
-      defaultIds,
-      modifiedIds
+      overrideIds
     });
   });
+  router.get("/defaults/:id", async (req, res) => {
+    const { id } = req.params;
+    const content = await getDefaultSkillContent(id);
+    if (!content) {
+      return res.status(404).json({ error: "Default skill not found" });
+    }
+    res.json(content);
+  });
   router.get("/default-ids", async (_req, res) => {
     const ids = await getDefaultSkillIds();
     res.json({ ids });
   });
-  router.post("/restore-all-defaults", async (_req, res) => {
-    const count = await restoreAllDefaultSkills(configDir);
-    res.json({ success: true, count });
-  });
-  router.post("/:id/restore-default", async (req, res) => {
-    const { id } = req.params;
-    const restored = await restoreDefaultSkill(configDir, id);
-    if (!restored) {
-      return res.status(404).json({ error: "No bundled default found for this skill" });
-    }
-    res.json({ success: true });
-  });
   router.post("/:id/toggle", (req, res) => {
     const { id } = req.params;
     const currentlyEnabled = isSkillEnabled(id);
@@ -5017,7 +4929,8 @@ function createSkillRoutes(configDir) {
     if (!/^[a-z0-9-]+$/.test(body.metadata.id)) {
       return res.status(400).json({ error: "Skill ID must be lowercase alphanumeric with hyphens only" });
     }
-    if (await skillExists(configDir, body.metadata.id)) {
+    const exists = await skillExists(configDir, body.metadata.id);
+    if (exists) {
       return res.status(409).json({ error: "A skill with this ID already exists" });
     }
     await saveSkill(configDir, body);
@@ -5025,15 +4938,12 @@ function createSkillRoutes(configDir) {
   });
   router.put("/:id", async (req, res) => {
     const { id } = req.params;
-    if (!await skillExists(configDir, id)) {
-      return res.status(404).json({ error: "Skill not found" });
-    }
-    const body = req.body;
     const skills = await loadAllSkills(configDir);
     const existing = findSkillById(id, skills);
     if (!existing) {
       return res.status(404).json({ error: "Skill not found" });
     }
+    const body = req.body;
     const updated = {
       metadata: { ...existing.metadata, ...body.metadata, id },
       prompt: body.prompt ?? existing.prompt
@@ -5043,47 +4953,205 @@ function createSkillRoutes(configDir) {
   });
   router.delete("/:id", async (req, res) => {
     const { id } = req.params;
-    const deleted = await deleteSkill(configDir, id);
-    if (!deleted) {
-      return res.status(404).json({ error: "Skill not found" });
+    const result = await deleteSkill(configDir, id);
+    if (!result.success) {
+      return res.status(403).json({ error: result.reason ?? "Cannot delete this skill" });
     }
     res.json({ success: true });
   });
+  router.post("/:id/duplicate", async (req, res) => {
+    const { id } = req.params;
+    const defaults = await loadDefaultSkills();
+    const userItems = await loadUserSkills(configDir);
+    const source = defaults.find((s) => s.metadata.id === id) ?? userItems.find((s) => s.metadata.id === id);
+    if (!source) {
+      return res.status(404).json({ error: "Skill not found" });
+    }
+    const newId = `${id}-copy-${Date.now()}`;
+    const duplicated = {
+      metadata: { ...source.metadata, id: newId, name: `${source.metadata.name} (copy)` },
+      prompt: source.prompt
+    };
+    await saveSkill(configDir, duplicated);
+    res.status(201).json(duplicated);
+  });
   return router;
 }
 
 // src/server/routes/commands.ts
 import { Router as Router2 } from "express";
+
+// src/server/commands/registry.ts
+import { join as join5 } from "path";
+
+// src/server/commands/registry-utils.ts
+import { readdir as readdir2, readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, access as access3, unlink as unlink2 } from "fs/promises";
+import { join as join4, dirname as dirname4 } from "path";
+import { constants as constants3 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import matter from "gray-matter";
+function getBundleDir() {
+  return dirname4(fileURLToPath3(import.meta.url));
+}
+async function dirExists(path) {
+  try {
+    await access3(path, constants3.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  if (!await dirExists(path)) {
+    await mkdir3(path, { recursive: true });
+  }
+}
+async function loadItems(dir, extension) {
+  if (!await dirExists(dir)) return [];
+  let files;
+  try {
+    files = (await readdir2(dir)).filter((f) => f.endsWith(extension));
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile3(join4(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 ${extension} file`, { file });
+      }
+    } catch (err) {
+      logger.warn(`Failed to parse ${extension} file`, { file, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return items;
+}
+async function saveItem(dir, id, extension, item) {
+  await ensureDir(dir);
+  const filePath = join4(dir, `${id}${extension}`);
+  const content = matter.stringify(item.prompt, item.metadata);
+  await writeFile3(filePath, content, "utf-8");
+}
+async function deleteItem(dir, id, extension) {
+  const filePath = join4(dir, `${id}${extension}`);
+  try {
+    await unlink2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findById(id, items) {
+  return items.find((i) => i.metadata.id === id);
+}
+async function getDefaultIds(bundleDir, defaultsDir, extension) {
+  try {
+    const files = (await readdir2(join4(bundleDir, defaultsDir))).filter((f) => f.endsWith(extension));
+    return files.map((f) => f.replace(extension, ""));
+  } catch {
+    return [];
+  }
+}
+async function loadDefaults(bundleDir, defaultsDir, extension) {
+  const dir = join4(bundleDir, defaultsDir);
+  return loadItems(dir, extension);
+}
+
+// src/server/commands/registry.ts
+var DEFAULTS_DIR2 = "defaults";
+var DEFAULTS_DIR_ALT2 = "command-defaults";
+var COMMAND_EXTENSION = ".command.md";
+function getCommandsDir(configDir) {
+  return join5(configDir, "commands");
+}
+async function loadDefaultCommands() {
+  const bundleDir = getBundleDir();
+  let defaults = await loadDefaults(bundleDir, DEFAULTS_DIR2, COMMAND_EXTENSION);
+  if (!defaults.length) {
+    defaults = await loadDefaults(bundleDir, DEFAULTS_DIR_ALT2, COMMAND_EXTENSION);
+  }
+  return defaults;
+}
+async function loadUserCommands(configDir) {
+  return loadItems(getCommandsDir(configDir), COMMAND_EXTENSION);
+}
+async function loadAllCommands(configDir) {
+  const [defaultCommands, userCommands] = await Promise.all([
+    loadDefaultCommands(),
+    loadUserCommands(configDir)
+  ]);
+  const commandMap = /* @__PURE__ */ new Map();
+  for (const cmd of defaultCommands) {
+    commandMap.set(cmd.metadata.id, cmd);
+  }
+  for (const cmd of userCommands) {
+    commandMap.set(cmd.metadata.id, cmd);
+  }
+  return Array.from(commandMap.values());
+}
+async function getDefaultCommandIds() {
+  const bundleDir = getBundleDir();
+  const ids = await getDefaultIds(bundleDir, DEFAULTS_DIR2, COMMAND_EXTENSION);
+  if (ids.length) return ids;
+  return getDefaultIds(bundleDir, DEFAULTS_DIR_ALT2, COMMAND_EXTENSION);
+}
+async function getDefaultCommandContent(commandId) {
+  const defaults = await loadDefaultCommands();
+  return defaults.find((c) => c.metadata.id === commandId) ?? null;
+}
+async function isDefaultCommand(commandId) {
+  const defaultIds = await getDefaultCommandIds();
+  return defaultIds.includes(commandId);
+}
+function findCommandById(commandId, commands) {
+  return findById(commandId, commands);
+}
+async function commandExists(configDir, commandId) {
+  return dirExists(join5(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`));
+}
+async function saveCommand(configDir, command) {
+  return saveItem(getCommandsDir(configDir), command.metadata.id, COMMAND_EXTENSION, command);
+}
+async function deleteCommand(configDir, commandId) {
+  const isDefault = await isDefaultCommand(commandId);
+  if (isDefault) {
+    return { success: false, reason: "Cannot delete built-in defaults" };
+  }
+  const deleted = await deleteItem(getCommandsDir(configDir), commandId, COMMAND_EXTENSION);
+  return { success: deleted };
+}
+
+// src/server/routes/commands.ts
 function createCommandRoutes(configDir) {
   const router = Router2();
   router.get("/", async (_req, res) => {
-    const [commands, defaultIds, modifiedIds] = await Promise.all([
-      loadAllCommands(configDir),
-      getDefaultCommandIds(),
-      getModifiedDefaultCommandIds(configDir)
+    const [defaults, userItems] = await Promise.all([
+      loadDefaultCommands(),
+      loadUserCommands(configDir)
     ]);
+    const overrideIds = computeOverrideIds(defaults, userItems);
     res.json({
-      commands: commands.map((c) => c.metadata),
-      defaultIds,
-      modifiedIds
+      defaults: defaults.map((c) => c.metadata),
+      userItems: userItems.map((c) => c.metadata),
+      overrideIds
     });
   });
+  router.get("/defaults/:id", async (req, res) => {
+    const { id } = req.params;
+    const content = await getDefaultCommandContent(id);
+    if (!content) {
+      return res.status(404).json({ error: "Default command not found" });
+    }
+    res.json(content);
+  });
   router.get("/default-ids", async (_req, res) => {
     const ids = await getDefaultCommandIds();
     res.json({ ids });
   });
-  router.post("/restore-all-defaults", async (_req, res) => {
-    const count = await restoreAllDefaultCommands(configDir);
-    res.json({ success: true, count });
-  });
-  router.post("/:id/restore-default", async (req, res) => {
-    const { id } = req.params;
-    const restored = await restoreDefaultCommand(configDir, id);
-    if (!restored) {
-      return res.status(404).json({ error: "No bundled default found for this command" });
-    }
-    res.json({ success: true });
-  });
   router.get("/:id", async (req, res) => {
     const { id } = req.params;
     const commands = await loadAllCommands(configDir);
@@ -5101,7 +5169,8 @@ function createCommandRoutes(configDir) {
     if (!/^[a-z0-9-]+$/.test(body.metadata.id)) {
       return res.status(400).json({ error: "Command ID must be lowercase alphanumeric with hyphens only" });
     }
-    if (await commandExists(configDir, body.metadata.id)) {
+    const exists = await commandExists(configDir, body.metadata.id);
+    if (exists) {
       return res.status(409).json({ error: "A command with this ID already exists" });
     }
     await saveCommand(configDir, body);
@@ -5109,15 +5178,12 @@ function createCommandRoutes(configDir) {
   });
   router.put("/:id", async (req, res) => {
     const { id } = req.params;
-    if (!await commandExists(configDir, id)) {
-      return res.status(404).json({ error: "Command not found" });
-    }
-    const body = req.body;
     const commands = await loadAllCommands(configDir);
     const existing = findCommandById(id, commands);
     if (!existing) {
       return res.status(404).json({ error: "Command not found" });
     }
+    const body = req.body;
     const updated = {
       metadata: { ...existing.metadata, ...body.metadata, id },
       prompt: body.prompt ?? existing.prompt
@@ -5127,12 +5193,28 @@ function createCommandRoutes(configDir) {
   });
   router.delete("/:id", async (req, res) => {
     const { id } = req.params;
-    const deleted = await deleteCommand(configDir, id);
-    if (!deleted) {
-      return res.status(404).json({ error: "Command not found" });
+    const result = await deleteCommand(configDir, id);
+    if (!result.success) {
+      return res.status(403).json({ error: result.reason ?? "Cannot delete this command" });
     }
     res.json({ success: true });
   });
+  router.post("/:id/duplicate", async (req, res) => {
+    const { id } = req.params;
+    const defaults = await loadDefaultCommands();
+    const userItems = await loadUserCommands(configDir);
+    const source = defaults.find((c) => c.metadata.id === id) ?? userItems.find((c) => c.metadata.id === id);
+    if (!source) {
+      return res.status(404).json({ error: "Command not found" });
+    }
+    const newId = `${id}-copy-${Date.now()}`;
+    const duplicated = {
+      metadata: { ...source.metadata, id: newId, name: `${source.metadata.name} (copy)` },
+      prompt: source.prompt
+    };
+    await saveCommand(configDir, duplicated);
+    res.status(201).json(duplicated);
+  });
   return router;
 }
 
@@ -5141,33 +5223,29 @@ import { Router as Router3 } from "express";
 function createAgentRoutes(configDir) {
   const router = Router3();
   router.get("/", async (_req, res) => {
-    const [agents, defaultIds, modifiedIds] = await Promise.all([
-      loadAllAgents(configDir),
-      getDefaultAgentIds(),
-      getModifiedDefaultAgentIds(configDir)
+    const [defaults, userItems] = await Promise.all([
+      loadDefaultAgents(),
+      loadUserAgents(configDir)
     ]);
+    const overrideIds = computeOverrideIds(defaults, userItems);
     res.json({
-      agents: agents.map((a) => a.metadata),
-      defaultIds,
-      modifiedIds
+      defaults: defaults.map((a) => a.metadata),
+      userItems: userItems.map((a) => a.metadata),
+      overrideIds
     });
   });
+  router.get("/defaults/:id", async (req, res) => {
+    const { id } = req.params;
+    const content = await getDefaultAgentContent(id);
+    if (!content) {
+      return res.status(404).json({ error: "Default agent not found" });
+    }
+    res.json(content);
+  });
   router.get("/default-ids", async (_req, res) => {
     const ids = await getDefaultAgentIds();
     res.json({ ids });
   });
-  router.post("/restore-all-defaults", async (_req, res) => {
-    const count = await restoreAllDefaultAgents(configDir);
-    res.json({ success: true, count });
-  });
-  router.post("/:id/restore-default", async (req, res) => {
-    const { id } = req.params;
-    const restored = await restoreDefaultAgent(configDir, id);
-    if (!restored) {
-      return res.status(404).json({ error: "No bundled default found for this agent" });
-    }
-    res.json({ success: true });
-  });
   router.get("/:id", async (req, res) => {
     const { id } = req.params;
     const agents = await loadAllAgents(configDir);
@@ -5182,7 +5260,8 @@ function createAgentRoutes(configDir) {
     if (!body?.metadata?.id || !body?.prompt) {
       return res.status(400).json({ error: "Missing required fields: metadata.id, prompt" });
     }
-    if (await agentExists(configDir, body.metadata.id)) {
+    const exists = await agentExists(configDir, body.metadata.id);
+    if (exists) {
       return res.status(409).json({ error: "An agent with this ID already exists" });
     }
     await saveAgent(configDir, body);
@@ -5208,12 +5287,28 @@ function createAgentRoutes(configDir) {
   });
   router.delete("/:id", async (req, res) => {
     const { id } = req.params;
-    const deleted = await deleteAgent(configDir, id);
-    if (!deleted) {
-      return res.status(404).json({ error: "Agent not found" });
+    const result = await deleteAgent(configDir, id);
+    if (!result.success) {
+      return res.status(403).json({ error: result.reason ?? "Cannot delete this agent" });
     }
     res.json({ success: true });
   });
+  router.post("/:id/duplicate", async (req, res) => {
+    const { id } = req.params;
+    const defaults = await loadDefaultAgents();
+    const userItems = await loadUserAgents(configDir);
+    const source = defaults.find((a) => a.metadata.id === id) ?? userItems.find((a) => a.metadata.id === id);
+    if (!source) {
+      return res.status(404).json({ error: "Agent not found" });
+    }
+    const newId = `${id}-copy-${Date.now()}`;
+    const duplicated = {
+      metadata: { ...source.metadata, id: newId, name: `${source.metadata.name} (copy)` },
+      prompt: source.prompt
+    };
+    await saveAgent(configDir, duplicated);
+    res.status(201).json(duplicated);
+  });
   return router;
 }
 
@@ -5222,37 +5317,33 @@ import { Router as Router4 } from "express";
 function createWorkflowRoutes(configDir, config) {
   const router = Router4();
   router.get("/", async (_req, res) => {
-    const [workflows, defaultIds, modifiedIds] = await Promise.all([
-      loadAllWorkflows(configDir),
-      getDefaultWorkflowIds(),
-      getModifiedDefaultWorkflowIds(configDir)
+    const [defaults, userItems] = await Promise.all([
+      loadDefaultWorkflows(),
+      loadUserWorkflows(configDir)
     ]);
+    const overrideIds = computeOverrideIds(defaults, userItems);
     res.json({
-      workflows: workflows.map((p) => ({ ...p.metadata, startCondition: p.startCondition })),
+      defaults: defaults.map((p) => ({ ...p.metadata, startCondition: p.startCondition })),
+      userItems: userItems.map((p) => ({ ...p.metadata, startCondition: p.startCondition })),
       activeWorkflowId: config.activeWorkflowId ?? "default",
-      defaultIds,
-      modifiedIds
+      overrideIds
     });
   });
   router.get("/template-variables", (_req, res) => {
     res.json({ variables: TEMPLATE_VARIABLES });
   });
+  router.get("/defaults/:id", async (req, res) => {
+    const { id } = req.params;
+    const content = await getDefaultWorkflowContent(id);
+    if (!content) {
+      return res.status(404).json({ error: "Default workflow not found" });
+    }
+    res.json(content);
+  });
   router.get("/default-ids", async (_req, res) => {
     const ids = await getDefaultWorkflowIds();
     res.json({ ids });
   });
-  router.post("/restore-all-defaults", async (_req, res) => {
-    const count = await restoreAllDefaultWorkflows(configDir);
-    res.json({ success: true, count });
-  });
-  router.post("/:id/restore-default", async (req, res) => {
-    const { id } = req.params;
-    const restored = await restoreDefaultWorkflow(configDir, id);
-    if (!restored) {
-      return res.status(404).json({ error: "No bundled default found for this workflow" });
-    }
-    res.json({ success: true });
-  });
   router.get("/:id", async (req, res) => {
     const { id } = req.params;
     const workflows = await loadAllWorkflows(configDir);
@@ -5267,7 +5358,8 @@ function createWorkflowRoutes(configDir, config) {
     if (!body?.metadata?.id || !body?.steps?.length) {
       return res.status(400).json({ error: "Missing required fields: metadata.id, steps" });
     }
-    if (await workflowExists(configDir, body.metadata.id)) {
+    const exists = await workflowExists(configDir, body.metadata.id);
+    if (exists) {
       return res.status(409).json({ error: "A workflow with this ID already exists" });
     }
     await saveWorkflow(configDir, body);
@@ -5275,7 +5367,9 @@ function createWorkflowRoutes(configDir, config) {
   });
   router.put("/:id", async (req, res) => {
     const { id } = req.params;
-    if (!await workflowExists(configDir, id)) {
+    const workflows = await loadAllWorkflows(configDir);
+    const existing = findWorkflowById(id, workflows);
+    if (!existing) {
       return res.status(404).json({ error: "Workflow not found" });
     }
     const body = req.body;
@@ -5288,14 +5382,27 @@ function createWorkflowRoutes(configDir, config) {
   });
   router.delete("/:id", async (req, res) => {
     const { id } = req.params;
-    if (id === "default") {
-      return res.status(400).json({ error: "Cannot delete the default workflow" });
+    const result = await deleteWorkflow(configDir, id);
+    if (!result.success) {
+      return res.status(403).json({ error: result.reason ?? "Cannot delete this workflow" });
     }
-    const deleted = await deleteWorkflow(configDir, id);
-    if (!deleted) {
+    res.json({ success: true });
+  });
+  router.post("/:id/duplicate", async (req, res) => {
+    const { id } = req.params;
+    const defaults = await loadDefaultWorkflows();
+    const userItems = await loadUserWorkflows(configDir);
+    const source = defaults.find((w) => w.metadata.id === id) ?? userItems.find((w) => w.metadata.id === id);
+    if (!source) {
       return res.status(404).json({ error: "Workflow not found" });
     }
-    res.json({ success: true });
+    const newId = `${id}-copy-${Date.now()}`;
+    const duplicated = {
+      ...source,
+      metadata: { ...source.metadata, id: newId, name: `${source.metadata.name} (copy)` }
+    };
+    await saveWorkflow(configDir, duplicated);
+    res.status(201).json(duplicated);
   });
   return router;
 }
@@ -5419,10 +5526,10 @@ function createTerminalRoutes() {
 }
 
 // src/constants.ts
-var VERSION = "1.6.15";
+var VERSION = "1.6.16";
 
 // src/server/index.ts
-var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath4(import.meta.url));
 async function createServerHandle(config) {
   setRuntimeConfig(config);
   setLogLevel(config.logging?.level ?? void 0, config.mode);
@@ -5430,10 +5537,6 @@ async function createServerHandle(config) {
   const db = initDatabase(config);
   initEventStore(db);
   const configDir = getGlobalConfigDir(config.mode ?? "production");
-  await ensureDefaultSkills(configDir);
-  await ensureDefaultCommands(configDir);
-  await ensureDefaultAgents(configDir);
-  await ensureDefaultWorkflows(configDir);
   const providerManager = createProviderManager(config);
   const sessionManager = new SessionManager(providerManager);
   const useMock = process.env["OPENFOX_MOCK_LLM"] === "true";
@@ -5725,7 +5828,7 @@ async function createServerHandle(config) {
     if (!callId || approved === void 0) {
       return res.status(400).json({ error: "callId and approved are required" });
     }
-    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-VOWNOP6V.js");
+    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-55YICCVH.js");
     const result = providePathConfirmation2(callId, approved, alwaysAllow);
     if (!result.found) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
@@ -5750,7 +5853,7 @@ async function createServerHandle(config) {
     if (!callId || !answer) {
       return res.status(400).json({ error: "callId and answer are required" });
     }
-    const { provideAnswer: provideAnswer2 } = await import("./tools-VOWNOP6V.js");
+    const { provideAnswer: provideAnswer2 } = await import("./tools-55YICCVH.js");
     const found = provideAnswer2(callId, answer);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
@@ -5786,8 +5889,8 @@ async function createServerHandle(config) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-F2A2IMQB.js");
-    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-VOWNOP6V.js");
+    const { stopSessionExecution } = await import("./chat-handler-IY2XVOO6.js");
+    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-55YICCVH.js");
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
     cancelQuestionsForSession2(sessionId, "Session stopped by user");
@@ -6107,9 +6210,9 @@ async function createServerHandle(config) {
       const entries = await import("fs/promises").then((m) => m.readdir(resolvedPath, { withFileTypes: true }));
       const directories = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
         name: entry.name,
-        path: join5(resolvedPath, entry.name)
+        path: join6(resolvedPath, entry.name)
       })).sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname4(resolvedPath);
+      const parent = dirname5(resolvedPath);
       const hasParent = parent !== resolvedPath;
       res.json({
         current: resolvedPath,
@@ -6154,7 +6257,7 @@ async function createServerHandle(config) {
       }
     });
     app.get("/fox.svg", (_req, res) => {
-      readFile3(join5(webDir, "fox.svg")).then((content) => {
+      readFile4(join6(webDir, "fox.svg")).then((content) => {
         res.set("Content-Type", "image/svg+xml");
         res.send(content);
       }).catch(() => {
@@ -6163,7 +6266,7 @@ async function createServerHandle(config) {
     });
     app.use(
       "/sounds",
-      express.static(join5(webDir, "public", "sounds"), {
+      express.static(join6(webDir, "public", "sounds"), {
         setHeaders: (res) => {
           res.set("Content-Type", "audio/mpeg");
         }
@@ -6173,7 +6276,7 @@ async function createServerHandle(config) {
       if (req.path.startsWith("/api/")) {
         return;
       }
-      readFile3(join5(webDir, "index.html"), "utf-8").then((indexHtml) => viteServer.transformIndexHtml(req.originalUrl, indexHtml)).then((transformed) => res.send(transformed)).catch((err) => {
+      readFile4(join6(webDir, "index.html"), "utf-8").then((indexHtml) => viteServer.transformIndexHtml(req.originalUrl, indexHtml)).then((transformed) => res.send(transformed)).catch((err) => {
         logger.error("Error serving index.html", { error: err });
         res.status(500).send("Server error");
       });
@@ -6184,7 +6287,7 @@ async function createServerHandle(config) {
     const distWebDir = resolve(__dirname2, "web");
     app.use(
       "/assets",
-      express.static(join5(distWebDir, "assets"), {
+      express.static(join6(distWebDir, "assets"), {
         setHeaders: (res, filepath) => {
           if (filepath.endsWith(".css")) {
             res.set("Content-Type", "text/css");
@@ -6192,11 +6295,11 @@ async function createServerHandle(config) {
         }
       })
     );
-    app.use("/manifest.webmanifest", express.static(join5(distWebDir, "manifest.webmanifest")));
-    app.use("/registerSW.js", express.static(join5(distWebDir, "registerSW.js")));
-    app.use("/sw.js", express.static(join5(distWebDir, "sw.js")));
+    app.use("/manifest.webmanifest", express.static(join6(distWebDir, "manifest.webmanifest")));
+    app.use("/registerSW.js", express.static(join6(distWebDir, "registerSW.js")));
+    app.use("/sw.js", express.static(join6(distWebDir, "sw.js")));
     app.get("/fox.svg", (_req, res) => {
-      readFile3(join5(distWebDir, "fox.svg")).then((content) => {
+      readFile4(join6(distWebDir, "fox.svg")).then((content) => {
         res.set("Content-Type", "image/svg+xml");
         res.send(content);
       }).catch(() => {
@@ -6205,14 +6308,14 @@ async function createServerHandle(config) {
     });
     app.use(
       "/sounds",
-      express.static(join5(distWebDir, "sounds"), {
+      express.static(join6(distWebDir, "sounds"), {
         setHeaders: (res) => {
           res.set("Content-Type", "audio/mpeg");
         }
       })
     );
     app.get("/", (_req, res) => {
-      readFile3(join5(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
+      readFile4(join6(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built. Run `npm run build:web`");
       });
     });
@@ -6220,7 +6323,7 @@ async function createServerHandle(config) {
       if (req.path.startsWith("/api/") || req.path.startsWith("/assets/") || req.path.startsWith("/sounds/") || req.path.startsWith("/manifest.webmanifest") || req.path.startsWith("/registerSW.js") || req.path.startsWith("/sw.js") || req.path === "/fox.svg") {
         return;
       }
-      readFile3(join5(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
+      readFile4(join6(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built");
       });
     });
@@ -6235,7 +6338,7 @@ async function createServerHandle(config) {
     providerManager
   );
   const wss = wssExports.wss;
-  const { QueueProcessor } = await import("./processor-H5BQ5HQM.js");
+  const { QueueProcessor } = await import("./processor-VUEJM73B.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -6308,4 +6411,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-G4E72ST3.js.map
+//# sourceMappingURL=chunk-NN65D5SI.js.map