@standardagents/builder 0.37.0 → 0.37.1

package/dist/plugin.js

@@ -1,7 +1,7 @@
-import * as fs8 from 'fs';
-import fs8__default from 'fs';
-import * as path8 from 'path';
-import path8__default from 'path';
+import * as fs9 from 'fs';
+import fs9__default from 'fs';
+import * as path9 from 'path';
+import path9__default from 'path';
 import { fileURLToPath } from 'url';
 import MagicString from 'magic-string';
 import { exec } from 'child_process';
@@ -41,15 +41,15 @@ function extractSchemaFields(content) {
 }
 function scanPromptsWithSchemas(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -65,15 +65,15 @@ function scanPromptsWithSchemas(dir) {
 }
 function scanAgentsWithSideA(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -93,15 +93,15 @@ function scanAgentsWithSideA(dir) {
 }
 function scanForNames(dir, useFilename = false) {
   const names = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return names;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         if (useFilename) {
           const toolName = entry.name.replace(/\.ts$/, "");
           if (content.includes("defineTool")) {
@@ -122,18 +122,18 @@ function scanForNames(dir, useFilename = false) {
 }
 function scanHooksForIds(dir) {
   const hookIds = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return hookIds;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         if (entry.name === "index.ts") {
           continue;
         }
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/defineHook\s*\(\s*\{[^}]*id:\s*['"]([^'"]+)['"]/s);
         if (idMatch) {
           hookIds.push(idMatch[1]);
@@ -801,44 +801,44 @@ declare module 'virtual:@standardagents/router' {
 `;
 }
 function ensureDir(dir) {
-  if (!fs8__default.existsSync(dir)) {
-    fs8__default.mkdirSync(dir, { recursive: true });
+  if (!fs9__default.existsSync(dir)) {
+    fs9__default.mkdirSync(dir, { recursive: true });
   }
 }
 function writeFileIfChanged(filePath, content) {
-  if (fs8__default.existsSync(filePath)) {
-    const existing = fs8__default.readFileSync(filePath, "utf-8");
+  if (fs9__default.existsSync(filePath)) {
+    const existing = fs9__default.readFileSync(filePath, "utf-8");
     if (existing === content) {
       return;
     }
   }
-  fs8__default.writeFileSync(filePath, content);
+  fs9__default.writeFileSync(filePath, content);
 }
 function generateTypes(config) {
   ensureDir(config.outputDir);
   const typesContent = generateTypesContent(config);
-  writeFileIfChanged(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
+  writeFileIfChanged(path9__default.join(config.outputDir, "types.d.ts"), typesContent);
   const virtualModuleContent = generateVirtualModuleContent();
-  writeFileIfChanged(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
-  writeFileIfChanged(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
-  writeFileIfChanged(path8__default.join(config.outputDir, ".gitignore"), "*\n");
+  writeFileIfChanged(path9__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  writeFileIfChanged(path9__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  writeFileIfChanged(path9__default.join(config.outputDir, ".gitignore"), "*\n");
 }
 function needsRegeneration(config) {
-  const typesPath = path8__default.join(config.outputDir, "types.d.ts");
-  if (!fs8__default.existsSync(typesPath)) {
+  const typesPath = path9__default.join(config.outputDir, "types.d.ts");
+  if (!fs9__default.existsSync(typesPath)) {
     return true;
   }
-  const typesMtime = fs8__default.statSync(typesPath).mtime;
+  const typesMtime = fs9__default.statSync(typesPath).mtime;
   const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir, config.hooksDir];
   for (const dir of dirs) {
-    if (!fs8__default.existsSync(dir)) {
+    if (!fs9__default.existsSync(dir)) {
       continue;
     }
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const fileMtime = fs8__default.statSync(filePath).mtime;
+        const filePath = path9__default.join(dir, entry.name);
+        const fileMtime = fs9__default.statSync(filePath).mtime;
         if (fileMtime > typesMtime) {
           return true;
         }
@@ -1044,7 +1044,7 @@ function createHmrReloader() {
     versions,
     invalidateSourceFileModule(server, filePath) {
       if (!filePath) return;
-      const absolutePath = path8__default.resolve(filePath);
+      const absolutePath = path9__default.resolve(filePath);
       for (const [envName, env] of Object.entries(server.environments)) {
         const modules = env.moduleGraph.getModulesByFile(absolutePath);
         if (!modules) continue;
@@ -1055,10 +1055,10 @@ function createHmrReloader() {
       }
     },
     invalidateSourceDirectoryModules(server, dirPath) {
-      if (!fs8__default.existsSync(dirPath)) return;
+      if (!fs9__default.existsSync(dirPath)) return;
       const scan = (currentDir) => {
-        for (const entry of fs8__default.readdirSync(currentDir, { withFileTypes: true })) {
-          const nextPath = path8__default.join(currentDir, entry.name);
+        for (const entry of fs9__default.readdirSync(currentDir, { withFileTypes: true })) {
+          const nextPath = path9__default.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             scan(nextPath);
           } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -1222,12 +1222,12 @@ function createHmrReloader() {
   };
   return reloader;
 }
-var STATE_RELATIVE_PATH = path8__default.join(".agents", "bootstrap-session.json");
+var STATE_RELATIVE_PATH = path9__default.join(".agents", "bootstrap-session.json");
 var PROJECT_ROOT_ENV_KEYS = ["INIT_CWD", "PWD", "npm_config_local_prefix"];
 function uniquePaths(paths) {
   return Array.from(
     new Set(
-      paths.filter((value) => !!value?.trim()).map((value) => path8__default.resolve(value))
+      paths.filter((value) => !!value?.trim()).map((value) => path9__default.resolve(value))
     )
   );
 }
@@ -1243,11 +1243,11 @@ function mergeCookieHeader(cookieHeader, injectedCookie) {
   return raw ? `${raw}; ${injectedCookie}` : injectedCookie;
 }
 function loadLocalBootstrapSession(projectRoot) {
-  const statePath = path8__default.join(projectRoot, STATE_RELATIVE_PATH);
-  if (!fs8__default.existsSync(statePath)) return null;
+  const statePath = path9__default.join(projectRoot, STATE_RELATIVE_PATH);
+  if (!fs9__default.existsSync(statePath)) return null;
   try {
     const parsed = JSON.parse(
-      fs8__default.readFileSync(statePath, "utf-8")
+      fs9__default.readFileSync(statePath, "utf-8")
     );
     if (parsed.version !== 1) return null;
     if (!parsed.endpoint || !parsed.user?.id || !parsed.account?.id) return null;
@@ -1264,7 +1264,7 @@ function findLocalBootstrapSession(projectRoot, env) {
   const envSession = loadLocalBootstrapSessionFromEnv();
   if (envSession) {
     return {
-      projectRoot: projectRoot ? path8__default.resolve(projectRoot) : process.cwd(),
+      projectRoot: projectRoot ? path9__default.resolve(projectRoot) : process.cwd(),
       session: envSession
     };
   }
@@ -1909,23 +1909,23 @@ function nameToFilename(name) {
 }
 function getModelFilePath(modelsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(modelsDir, `${filename}.ts`);
+  return path9__default.join(modelsDir, `${filename}.ts`);
 }
 function getProviderFilePath(providersDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(providersDir, `${filename}.ts`);
+  return path9__default.join(providersDir, `${filename}.ts`);
 }
 function extensionlessImportPath(fromDir, toFile) {
-  let relative2 = path8__default.relative(fromDir, toFile).replace(/\\/g, "/").replace(/\.ts$/, "");
-  if (!relative2.startsWith(".")) {
-    relative2 = `./${relative2}`;
+  let relative4 = path9__default.relative(fromDir, toFile).replace(/\\/g, "/").replace(/\.ts$/, "");
+  if (!relative4.startsWith(".")) {
+    relative4 = `./${relative4}`;
   }
-  return relative2;
+  return relative4;
 }
 function getLocalProviderInfo(modelsDir, providersDir, providerName) {
   if (!providersDir) return null;
   const providerPath = getProviderFilePath(providersDir, providerName);
-  if (!fs8__default.existsSync(providerPath)) return null;
+  if (!fs9__default.existsSync(providerPath)) return null;
   return {
     name: nameToFilename(providerName),
     package: extensionlessImportPath(modelsDir, providerPath),
@@ -1934,15 +1934,15 @@ function getLocalProviderInfo(modelsDir, providersDir, providerName) {
 }
 function modelExists(modelsDir, name) {
   const filePath = getModelFilePath(modelsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 async function saveModel(modelsDir, data, overwrite = false, providerPackageMap = defaultProviderPackageMap, providersDir) {
   try {
-    if (!fs8__default.existsSync(modelsDir)) {
-      fs8__default.mkdirSync(modelsDir, { recursive: true });
+    if (!fs9__default.existsSync(modelsDir)) {
+      fs9__default.mkdirSync(modelsDir, { recursive: true });
     }
     const filePath = getModelFilePath(modelsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file already exists: ${filePath}. Use update to modify existing models.`
@@ -1950,7 +1950,7 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
     }
     const providerInfo = providerPackageMap[data.provider] ?? getLocalProviderInfo(modelsDir, providersDir, data.provider);
     if (!providerInfo) {
-      const localProviderNames = providersDir && fs8__default.existsSync(providersDir) ? fs8__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
+      const localProviderNames = providersDir && fs9__default.existsSync(providersDir) ? fs9__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
       const validProviders = [...Object.keys(providerPackageMap), ...localProviderNames];
       return {
         success: false,
@@ -1962,7 +1962,7 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
       providerPackage: providerInfo.package,
       defaultImport: providerInfo.defaultImport
     });
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1977,13 +1977,13 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
 async function deleteModel(modelsDir, name) {
   try {
     const filePath = getModelFilePath(modelsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2029,7 +2029,7 @@ function validateModelDataWithProviders(data, providerPackageMap, providersDir)
     const validProviders = Object.keys(providerPackageMap);
     const hasLocalProvider = Boolean(getLocalProviderInfo(process.cwd(), providersDir, data.provider));
     if (!validProviders.includes(data.provider) && !hasLocalProvider) {
-      const localProviderNames = providersDir && fs8__default.existsSync(providersDir) ? fs8__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
+      const localProviderNames = providersDir && fs9__default.existsSync(providersDir) ? fs9__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
       errors["provider"] = `Invalid provider '${data.provider}'. Must be one of: ${[...validProviders, ...localProviderNames].join(", ")}`;
     }
   }
@@ -2246,26 +2246,26 @@ function transformPromptData(data) {
 }
 function getPromptFilePath(promptsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(promptsDir, `${filename}.ts`);
+  return path9__default.join(promptsDir, `${filename}.ts`);
 }
 function promptExists(promptsDir, name) {
   const filePath = getPromptFilePath(promptsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 async function savePrompt(promptsDir, data, overwrite = false) {
   try {
-    if (!fs8__default.existsSync(promptsDir)) {
-      fs8__default.mkdirSync(promptsDir, { recursive: true });
+    if (!fs9__default.existsSync(promptsDir)) {
+      fs9__default.mkdirSync(promptsDir, { recursive: true });
     }
     const filePath = getPromptFilePath(promptsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
       };
     }
     const content = generatePromptFile(data);
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -2280,13 +2280,13 @@ async function savePrompt(promptsDir, data, overwrite = false) {
 async function deletePrompt(promptsDir, name) {
   try {
     const filePath = getPromptFilePath(promptsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2302,25 +2302,25 @@ async function renamePrompt(promptsDir, oldName, newName) {
   try {
     const oldFilePath = getPromptFilePath(promptsDir, oldName);
     const newFilePath = getPromptFilePath(promptsDir, newName);
-    if (!fs8__default.existsSync(oldFilePath)) {
+    if (!fs9__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${oldFilePath}`
       };
     }
-    if (fs8__default.existsSync(newFilePath)) {
+    if (fs9__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${newFilePath}`
       };
     }
-    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs9__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs8__default.promises.unlink(oldFilePath);
+    await fs9__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs9__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -2620,15 +2620,15 @@ function transformAgentData(data) {
 }
 function getAgentFilePath(agentsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(agentsDir, `${filename}.ts`);
+  return path9__default.join(agentsDir, `${filename}.ts`);
 }
 function agentExists(agentsDir, name) {
   const filePath = getAgentFilePath(agentsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 function extractAgentMetadata(filePath) {
   try {
-    const content = fs8__default.readFileSync(filePath, "utf-8");
+    const content = fs9__default.readFileSync(filePath, "utf-8");
     const metadata = {};
     const packageNameMatch = content.match(/packageName:\s*['"]([^'"]+)['"]/);
     if (packageNameMatch) metadata.packageName = packageNameMatch[1];
@@ -2645,17 +2645,17 @@ function extractAgentMetadata(filePath) {
 }
 async function saveAgent(agentsDir, data, overwrite = false) {
   try {
-    if (!fs8__default.existsSync(agentsDir)) {
-      fs8__default.mkdirSync(agentsDir, { recursive: true });
+    if (!fs9__default.existsSync(agentsDir)) {
+      fs9__default.mkdirSync(agentsDir, { recursive: true });
     }
     const filePath = getAgentFilePath(agentsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
       };
     }
-    if (overwrite && fs8__default.existsSync(filePath)) {
+    if (overwrite && fs9__default.existsSync(filePath)) {
       const existingMetadata = extractAgentMetadata(filePath);
       if (existingMetadata.packageName && !data.packageName) {
         data.packageName = existingMetadata.packageName;
@@ -2671,7 +2671,7 @@ async function saveAgent(agentsDir, data, overwrite = false) {
       }
     }
     const content = generateAgentFile(data);
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -2686,13 +2686,13 @@ async function saveAgent(agentsDir, data, overwrite = false) {
 async function deleteAgent(agentsDir, name) {
   try {
     const filePath = getAgentFilePath(agentsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2708,25 +2708,25 @@ async function renameModel(modelsDir, oldName, newName) {
   try {
     const oldFilePath = getModelFilePath(modelsDir, oldName);
     const newFilePath = getModelFilePath(modelsDir, newName);
-    if (!fs8__default.existsSync(oldFilePath)) {
+    if (!fs9__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Model file not found: ${oldFilePath}`
       };
     }
-    if (fs8__default.existsSync(newFilePath)) {
+    if (fs9__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Model file already exists: ${newFilePath}`
       };
     }
-    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs9__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs8__default.promises.unlink(oldFilePath);
+    await fs9__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs9__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -2740,17 +2740,17 @@ async function renameModel(modelsDir, oldName, newName) {
 }
 async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(promptsDir)) {
+  if (!fs9__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(promptsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(promptsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     const modelRegex = new RegExp(`model:\\s*['"]${escapeRegExp(oldModelName)}['"]`, "g");
     if (modelRegex.test(content)) {
       content = content.replace(modelRegex, `model: '${newModelName}'`);
-      await fs8__default.promises.writeFile(filePath, content, "utf-8");
+      await fs9__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2758,13 +2758,13 @@ async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModel
 }
 async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(promptsDir)) {
+  if (!fs9__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(promptsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(promptsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     let modified = false;
     const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
     const newContent = content.replace(toolsArrayRegex, (match) => {
@@ -2777,7 +2777,7 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
       return replaced;
     });
     if (modified) {
-      await fs8__default.promises.writeFile(filePath, newContent, "utf-8");
+      await fs9__default.promises.writeFile(filePath, newContent, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2785,17 +2785,17 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
 }
 async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(agentsDir)) {
+  if (!fs9__default.existsSync(agentsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(agentsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(agentsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     const promptRegex = new RegExp(`prompt:\\s*['"]${escapeRegExp(oldPromptName)}['"]`, "g");
     if (promptRegex.test(content)) {
       content = content.replace(promptRegex, `prompt: '${newPromptName}'`);
-      await fs8__default.promises.writeFile(filePath, content, "utf-8");
+      await fs9__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2922,16 +2922,16 @@ function parseThreadEndpointRouteKey(input) {
   };
 }
 function scanThreadEndpointFiles(dir, options = {}) {
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return [];
   }
   const extensions = options.extensions ?? [".ts"];
   const routes = [];
   const scan = (currentDir, relativeDir = "") => {
-    const entries = fs8__default.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const filePath = path8__default.join(currentDir, entry.name);
-      const relativePath = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
+      const filePath = path9__default.join(currentDir, entry.name);
+      const relativePath = relativeDir ? path9__default.posix.join(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         scan(filePath, relativePath);
         continue;
@@ -2965,7 +2965,7 @@ function scanApiDirectory(dir) {
   try {
     return scanThreadEndpointFiles(dir, {
       extensions: [".ts"],
-      importPathForFile: (filePath) => "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
+      importPathForFile: (filePath) => "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
     }).map(({ method, route, importPath }) => ({
       method,
       route,
@@ -2977,26 +2977,26 @@ function scanApiDirectory(dir) {
   }
 }
 function discoverPackedPackageDirectories(packedDir) {
-  if (!fs8__default.existsSync(packedDir)) {
+  if (!fs9__default.existsSync(packedDir)) {
     return [];
   }
   const packageDirs = [];
-  const entries = fs8__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  const entries = fs9__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const entry of entries) {
-    const fullPath = path8__default.join(packedDir, entry.name);
-    const packageJsonPath = path8__default.join(fullPath, "package.json");
-    if (fs8__default.existsSync(packageJsonPath)) {
+    const fullPath = path9__default.join(packedDir, entry.name);
+    const packageJsonPath = path9__default.join(fullPath, "package.json");
+    if (fs9__default.existsSync(packageJsonPath)) {
       packageDirs.push(fullPath);
       continue;
     }
     if (!entry.name.startsWith("@")) {
       continue;
     }
-    const scopedEntries = fs8__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
+    const scopedEntries = fs9__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
     for (const scopedEntry of scopedEntries) {
-      const scopedPackagePath = path8__default.join(fullPath, scopedEntry.name);
-      const scopedPackageJson = path8__default.join(scopedPackagePath, "package.json");
-      if (fs8__default.existsSync(scopedPackageJson)) {
+      const scopedPackagePath = path9__default.join(fullPath, scopedEntry.name);
+      const scopedPackageJson = path9__default.join(scopedPackagePath, "package.json");
+      if (fs9__default.existsSync(scopedPackageJson)) {
         packageDirs.push(scopedPackagePath);
       }
     }
@@ -3004,26 +3004,26 @@ function discoverPackedPackageDirectories(packedDir) {
   return packageDirs;
 }
 function scanPackedDistDirectory(packagePath, outputDir, subDir) {
-  const fullPath = path8__default.join(packagePath, outputDir, subDir);
-  if (!fs8__default.existsSync(fullPath)) {
+  const fullPath = path9__default.join(packagePath, outputDir, subDir);
+  if (!fs9__default.existsSync(fullPath)) {
     return [];
   }
-  return fs8__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
+  return fs9__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
     name: fileName.replace(/\.(js|ts)$/, ""),
-    path: path8__default.join(fullPath, fileName).replace(/\\/g, "/")
+    path: path9__default.join(fullPath, fileName).replace(/\\/g, "/")
   }));
 }
 function scanPackedThreadEndpoints(packagePath, outputDir) {
-  const rootDir = path8__default.join(packagePath, outputDir, "thread-endpoints");
-  if (!fs8__default.existsSync(rootDir)) {
+  const rootDir = path9__default.join(packagePath, outputDir, "thread-endpoints");
+  if (!fs9__default.existsSync(rootDir)) {
     return [];
   }
   const endpoints = [];
   const scan = (dir, relativeDir = "") => {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const nextRelative = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = path8__default.join(dir, entry.name);
+      const nextRelative = relativeDir ? path9__default.posix.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path9__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         scan(absolutePath, nextRelative);
         continue;
@@ -3053,7 +3053,7 @@ function isSnakeCase(str) {
 }
 function validateToolFile(filePath, fileName) {
   try {
-    const content = fs8__default.readFileSync(filePath, "utf-8");
+    const content = fs9__default.readFileSync(filePath, "utf-8");
     const hasDefaultExport = /export\s+default\s+defineTool/.test(content);
     if (!hasDefaultExport) {
       return `Tool file '${fileName}.ts' must have a default export using defineTool()`;
@@ -3065,15 +3065,15 @@ function validateToolFile(filePath, fileName) {
 }
 async function scanToolsDirectory(dir) {
   const tools = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return tools;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       let toolError;
       const validationError = validateToolFile(filePath, fileName);
       if (validationError) {
@@ -3100,18 +3100,18 @@ async function scanToolsDirectory(dir) {
 }
 async function scanHooksDirectory(dir) {
   const hooks = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return hooks;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
       if (fileName === "index") continue;
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/id:\s*['"]([^'"]+)['"]/);
         const hookMatch = content.match(/hook:\s*['"]([^'"]+)['"]/);
         if (idMatch && hookMatch) {
@@ -3134,16 +3134,16 @@ async function scanHooksDirectory(dir) {
 }
 async function scanConfigDirectory(dir, definePattern) {
   const items = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return items;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const hasDefaultExport = definePattern.test(content);
         if (!hasDefaultExport) {
           items.push({
@@ -3188,20 +3188,20 @@ async function scanAgentsDirectory(dir) {
 }
 async function scanEffectsDirectory(dir) {
   const effects = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return effects;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       if (fileName === "CLAUDE" || fileName.startsWith("_")) {
         continue;
       }
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         if (!content.includes("defineEffect")) {
           continue;
         }
@@ -3214,14 +3214,14 @@ async function scanEffectsDirectory(dir) {
   return effects;
 }
 function parseRequestBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
     req.on("end", () => {
       try {
-        resolve2(body ? JSON.parse(body) : {});
+        resolve3(body ? JSON.parse(body) : {});
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -3231,17 +3231,17 @@ function parseRequestBody(req) {
 }
 function scanUsersDirectory(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) return results;
+  if (!fs9__default.existsSync(dir)) return results;
   const walk = (current, prefix) => {
     let entries;
     try {
-      entries = fs8__default.readdirSync(current, { withFileTypes: true });
+      entries = fs9__default.readdirSync(current, { withFileTypes: true });
     } catch (error) {
       console.error(`Error scanning users directory ${current}:`, error);
       return;
     }
     for (const entry of entries) {
-      const fullPath = path8__default.join(current, entry.name);
+      const fullPath = path9__default.join(current, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, prefix ? `${prefix}/${entry.name}` : entry.name);
         continue;
@@ -3251,7 +3251,7 @@ function scanUsersDirectory(dir) {
       const key = prefix ? `${prefix}/${base}` : base;
       results.push({
         key,
-        importPath: "./" + path8__default.relative(process.cwd(), fullPath).replace(/\\/g, "/")
+        importPath: "./" + path9__default.relative(process.cwd(), fullPath).replace(/\\/g, "/")
       });
     }
   };
@@ -3484,7 +3484,7 @@ async function handleModelApiRequest(context) {
         }
         await hmr.reloadRouterModule(server);
         await hmr.reloadBuilderModule(server);
-        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        await new Promise((resolve3) => setTimeout(resolve3, 100));
         res.statusCode = 200;
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify({
@@ -3711,6 +3711,49 @@ async function handleConfigApiRequest(context) {
   if (await handleAgentApiRequest(context)) return true;
   return false;
 }
+
+// src/packing/package-identifier.ts
+function assertSafePackageIdentifier(identifier) {
+  const value = identifier.trim();
+  if (!value || value.includes("\\") || value.includes("\0") || value.startsWith("/")) {
+    throw new Error("Invalid package identifier");
+  }
+  const parts = value.split("/");
+  const scoped = parts.length === 2 && parts[0].startsWith("@");
+  if (parts.length > 1 && !scoped) throw new Error("Invalid package identifier");
+  if (parts.some((part) => !part || part === "." || part === ".." || !/^@?[a-zA-Z0-9._-]+$/.test(part))) {
+    throw new Error("Invalid package identifier");
+  }
+  return value;
+}
+
+// src/packing/path-safety.ts
+function isWithin(base, candidate) {
+  const relative4 = path9.relative(base, candidate);
+  return relative4 === "" || !relative4.startsWith(`..${path9.sep}`) && relative4 !== ".." && !path9.isAbsolute(relative4);
+}
+function resolvePathWithin(base, ...segments) {
+  const resolvedBase = path9.resolve(base);
+  const candidate = path9.resolve(resolvedBase, ...segments);
+  if (!isWithin(resolvedBase, candidate)) {
+    throw new Error("Path must remain inside the configured AgentBuilder directory");
+  }
+  if (fs9.existsSync(resolvedBase)) {
+    const realBase = fs9.realpathSync(resolvedBase);
+    if (typeof realBase !== "string") return candidate;
+    let existing = candidate;
+    while (!fs9.existsSync(existing) && existing !== resolvedBase) {
+      existing = path9.dirname(existing);
+    }
+    if (fs9.existsSync(existing)) {
+      const realExisting = fs9.realpathSync(existing);
+      if (typeof realExisting === "string" && !isWithin(realBase, realExisting)) {
+        throw new Error("Path traverses a symlink outside the configured AgentBuilder directory");
+      }
+    }
+  }
+  return candidate;
+}
 var MetadataService = class {
   metadataDir;
   /**
@@ -3719,7 +3762,7 @@ var MetadataService = class {
    * @param agentsDir - Path to the agents/ directory
    */
   constructor(agentsDir) {
-    this.metadataDir = path8.join(agentsDir, ".standardagent");
+    this.metadataDir = path9.join(agentsDir, ".standardagent");
   }
   /**
    * Read metadata for an agent.
@@ -3729,11 +3772,11 @@ var MetadataService = class {
    */
   async read(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = fs8.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -3746,11 +3789,11 @@ var MetadataService = class {
    * @param metadata - Metadata to write
    */
   async write(agentName, metadata) {
-    if (!fs8.existsSync(this.metadataDir)) {
-      fs8.mkdirSync(this.metadataDir, { recursive: true });
+    if (!fs9.existsSync(this.metadataDir)) {
+      fs9.mkdirSync(this.metadataDir, { recursive: true });
     }
     const filePath = this.getMetadataPath(agentName);
-    fs8.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+    fs9.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Delete metadata for an agent.
@@ -3759,8 +3802,8 @@ var MetadataService = class {
    */
   async delete(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (fs8.existsSync(filePath)) {
-      fs8.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) {
+      fs9.unlinkSync(filePath);
     }
   }
   /**
@@ -3841,7 +3884,7 @@ var MetadataService = class {
    * Get the file path for an agent's metadata.
    */
   getMetadataPath(agentName) {
-    return path8.join(this.metadataDir, `${agentName}.json`);
+    return path9.join(this.metadataDir, `${agentName}.json`);
   }
 };
 var _ts;
@@ -4213,9 +4256,9 @@ var PackingService = class {
    * @returns Version specifier (e.g., '^1.2.3') or '*' if not found
    */
   resolvePackageVersion(pkgName, rootDir) {
-    const pkgJsonPath = path8.join(rootDir, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path9.join(rootDir, "node_modules", pkgName, "package.json");
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       return `^${pkgJson.version}`;
     } catch {
       return "*";
@@ -4232,7 +4275,7 @@ var PackingService = class {
    * @returns Analysis result with all discovered constituents
    */
   async analyzeAgent(agentName, rootDir) {
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const analysis = {
       agent: agentName,
       primaryPrompt: "",
@@ -4256,7 +4299,7 @@ var PackingService = class {
       warnings: [],
       errors: []
     };
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.errors.push(`Agent file not found: ${agentName}`);
       return analysis;
@@ -4267,7 +4310,7 @@ var PackingService = class {
       discoveredVia: "static",
       sharedWith: []
     });
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
@@ -4292,13 +4335,13 @@ var PackingService = class {
    * @returns Object with generatedReadme and agentDescription
    */
   async generateReadmeForAnalysis(analysis, rootDir) {
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const metadataService = new MetadataService(agentsDir);
     let agentDescription;
     const agentItem = analysis.constituents.agents.find((a) => a.name === analysis.agent);
     if (agentItem?.filePath) {
       try {
-        const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
+        const agentSource = fs9.readFileSync(agentItem.filePath, "utf-8");
         agentDescription = await extractAgentDescription(agentSource) || void 0;
       } catch {
       }
@@ -4322,7 +4365,7 @@ var PackingService = class {
    * include all endpoint modules discovered under agents/api.
    */
   async analyzeThreadEndpoints(agentsDir, analysis) {
-    const apiDir = path8.join(agentsDir, "api");
+    const apiDir = path9.join(agentsDir, "api");
     const endpoints = this.scanThreadEndpointFiles(apiDir);
     for (const endpoint of endpoints) {
       if (analysis.constituents.threadEndpoints.some((item) => item.name === endpoint.name)) {
@@ -4344,15 +4387,15 @@ var PackingService = class {
    * - `admin/users/[userId]/sync.post`
    */
   scanThreadEndpointFiles(apiDir, relativeDir = "") {
-    if (!fs8.existsSync(apiDir)) {
+    if (!fs9.existsSync(apiDir)) {
       return [];
     }
     const endpoints = [];
-    const currentDir = relativeDir ? path8.join(apiDir, relativeDir) : apiDir;
-    if (!fs8.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path9.join(apiDir, relativeDir) : apiDir;
+    if (!fs9.existsSync(currentDir)) {
       return endpoints;
     }
-    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return endpoints;
     }
@@ -4360,8 +4403,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path8.join(apiDir, entryRelative);
+      const entryRelative = relativeDir ? path9.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path9.join(apiDir, entryRelative);
       if (isDirectory) {
         endpoints.push(...this.scanThreadEndpointFiles(apiDir, entryRelative));
         continue;
@@ -4388,7 +4431,7 @@ var PackingService = class {
    * include all effect modules discovered under agents/effects.
    */
   async analyzeEffects(agentsDir, analysis) {
-    const effectsDir = path8.join(agentsDir, "effects");
+    const effectsDir = path9.join(agentsDir, "effects");
     const effects = this.scanEffectFiles(effectsDir);
     for (const effect of effects) {
       if (analysis.constituents.effects.some((item) => item.name === effect.name)) {
@@ -4410,15 +4453,15 @@ var PackingService = class {
    * - `notifications/digest`
    */
   scanEffectFiles(effectsDir, relativeDir = "") {
-    if (!fs8.existsSync(effectsDir)) {
+    if (!fs9.existsSync(effectsDir)) {
       return [];
     }
     const effects = [];
-    const currentDir = relativeDir ? path8.join(effectsDir, relativeDir) : effectsDir;
-    if (!fs8.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path9.join(effectsDir, relativeDir) : effectsDir;
+    if (!fs9.existsSync(currentDir)) {
       return effects;
     }
-    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return effects;
     }
@@ -4426,8 +4469,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path8.join(effectsDir, entryRelative);
+      const entryRelative = relativeDir ? path9.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path9.join(effectsDir, entryRelative);
       if (isDirectory) {
         effects.push(...this.scanEffectFiles(effectsDir, entryRelative));
         continue;
@@ -4451,7 +4494,7 @@ var PackingService = class {
    * Recursively analyze a prompt and its dependencies.
    */
   async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
-    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
+    const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), promptName);
     if (!promptFilePath) {
       analysis.warnings.push(`Prompt file not found: ${promptName}`);
       return;
@@ -4470,7 +4513,7 @@ var PackingService = class {
       return;
     }
     visited.add(`prompt:${promptName}`);
-    const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
+    const promptSource = fs9.readFileSync(promptFilePath, "utf-8");
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -4496,17 +4539,17 @@ var PackingService = class {
    */
   async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
     const thisKey = `tool:${toolName}`;
-    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), toolName);
+    const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), toolName);
     if (promptFilePath) {
       await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), toolName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), toolName);
     if (agentFilePath) {
       await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const toolFilePath = await this.findFile(path8.join(agentsDir, "tools"), toolName);
+    const toolFilePath = await this.findFile(path9.join(agentsDir, "tools"), toolName);
     if (!toolFilePath) {
       analysis.warnings.push(`Tool file not found: ${toolName}`);
       return;
@@ -4524,7 +4567,7 @@ var PackingService = class {
       return;
     }
     visited.add(`tool:${toolName}`);
-    const toolSource = fs8.readFileSync(toolFilePath, "utf-8");
+    const toolSource = fs9.readFileSync(toolFilePath, "utf-8");
     const { uses } = await extractToolUses(toolSource);
     for (const usedItem of uses) {
       await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
@@ -4534,7 +4577,7 @@ var PackingService = class {
    * Analyze a nested agent (used as a handoff target).
    */
   async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.warnings.push(`Agent file not found: ${agentName}`);
       return;
@@ -4553,7 +4596,7 @@ var PackingService = class {
       return;
     }
     visited.add(`agent:${agentName}`);
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
@@ -4566,7 +4609,7 @@ var PackingService = class {
    * Analyze a model and its fallbacks.
    */
   async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
-    const modelFilePath = await this.findFile(path8.join(agentsDir, "models"), modelName);
+    const modelFilePath = await this.findFile(path9.join(agentsDir, "models"), modelName);
     if (!modelFilePath) {
       analysis.warnings.push(`Model file not found: ${modelName}`);
       return;
@@ -4585,7 +4628,7 @@ var PackingService = class {
       return;
     }
     visited.add(`model:${modelName}`);
-    const modelSource = fs8.readFileSync(modelFilePath, "utf-8");
+    const modelSource = fs9.readFileSync(modelFilePath, "utf-8");
     const fallbacks = await extractModelFallbacks(modelSource);
     for (const fallbackName of fallbacks) {
       await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
@@ -4595,13 +4638,13 @@ var PackingService = class {
    * Check which items are shared with other agents.
    */
   async checkSharedItems(agentsDir, analysis) {
-    const agentsPath = path8.join(agentsDir, "agents");
-    if (!fs8.existsSync(agentsPath)) return;
-    const agentFiles = fs8.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    const agentsPath = path9.join(agentsDir, "agents");
+    if (!fs9.existsSync(agentsPath)) return;
+    const agentFiles = fs9.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
     for (const agentFile of agentFiles) {
       const otherAgentName = agentFile.replace(".ts", "");
       if (otherAgentName === analysis.agent) continue;
-      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path8.dirname(agentsDir));
+      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path9.dirname(agentsDir));
       for (const prompt of analysis.constituents.prompts) {
         if (otherAnalysis.prompts.includes(prompt.name)) {
           prompt.sharedWith.push(otherAgentName);
@@ -4633,19 +4676,19 @@ var PackingService = class {
    */
   async analyzeAgentLight(agentName, rootDir) {
     const result = { prompts: [], tools: [], models: [] };
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const visited = /* @__PURE__ */ new Set();
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) return result;
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     const analyzePromptLight = async (promptName) => {
       if (visited.has(promptName)) return;
       visited.add(promptName);
       result.prompts.push(promptName);
-      const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
+      const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), promptName);
       if (!promptFilePath) return;
-      const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
+      const promptSource = fs9.readFileSync(promptFilePath, "utf-8");
       const modelName = await extractPromptModel(promptSource);
       if (modelName && !result.models.includes(modelName)) {
         result.models.push(modelName);
@@ -4718,14 +4761,15 @@ var PackingService = class {
         return result;
       }
       result.warnings = analysis.warnings;
-      const pkgOutputDir = path8.join(outputDir, packageId);
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "effects"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
+      const safePackageId = assertSafePackageIdentifier(packageId);
+      const pkgOutputDir = resolvePathWithin(outputDir, safePackageId);
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "effects"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
       const seenItems = /* @__PURE__ */ new Set();
       const allItems = [];
       for (const a of analysis.constituents.agents) {
@@ -4779,13 +4823,13 @@ var PackingService = class {
       }
       const externalDeps = /* @__PURE__ */ new Map();
       for (const item of allItems) {
-        const outputPath = path8.join(
+        const outputPath = resolvePathWithin(
           pkgOutputDir,
           "dist",
           this.getTypeDir(item.type),
           `${item.name}.js`
         );
-        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
         const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
         for (const [depName, depVersion] of deps) {
           if (!externalDeps.has(depName)) {
@@ -4795,12 +4839,12 @@ var PackingService = class {
         result.filesCreated.push(outputPath);
       }
       const indexJs = this.generateReExportIndex(analysis, meta);
-      const indexJsPath = path8.join(pkgOutputDir, "dist", "index.js");
-      fs8.writeFileSync(indexJsPath, indexJs);
+      const indexJsPath = resolvePathWithin(pkgOutputDir, "dist", "index.js");
+      fs9.writeFileSync(indexJsPath, indexJs);
       result.filesCreated.push(indexJsPath);
       const indexDts = this.generateIndexDts(analysis);
-      const indexDtsPath = path8.join(pkgOutputDir, "dist", "index.d.ts");
-      fs8.writeFileSync(indexDtsPath, indexDts);
+      const indexDtsPath = resolvePathWithin(pkgOutputDir, "dist", "index.d.ts");
+      fs9.writeFileSync(indexDtsPath, indexDts);
       result.filesCreated.push(indexDtsPath);
       const pkgJson = this.generatePackageJson(
         finalPackageName,
@@ -4813,13 +4857,13 @@ var PackingService = class {
         license,
         licenseOwner
       );
-      const pkgJsonPath = path8.join(pkgOutputDir, "package.json");
-      fs8.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      const pkgJsonPath = path9.join(pkgOutputDir, "package.json");
+      fs9.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
       result.filesCreated.push(pkgJsonPath);
       if (license) {
         const licenseContent = this.generateLicenseFile(license, licenseOwner);
-        const licensePath = path8.join(pkgOutputDir, "LICENSE");
-        fs8.writeFileSync(licensePath, licenseContent);
+        const licensePath = path9.join(pkgOutputDir, "LICENSE");
+        fs9.writeFileSync(licensePath, licenseContent);
         result.filesCreated.push(licensePath);
       }
       let readmeContent = readme;
@@ -4827,7 +4871,7 @@ var PackingService = class {
         const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
         let agentDescription;
         if (agentItem?.filePath) {
-          const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
+          const agentSource = fs9.readFileSync(agentItem.filePath, "utf-8");
           agentDescription = await extractAgentDescription(agentSource) || void 0;
         }
         readmeContent = this.generateReadme(
@@ -4838,21 +4882,21 @@ var PackingService = class {
           agentDescription
         );
       }
-      const readmePath = path8.join(pkgOutputDir, "README.md");
-      fs8.writeFileSync(readmePath, readmeContent);
+      const readmePath = path9.join(pkgOutputDir, "README.md");
+      fs9.writeFileSync(readmePath, readmeContent);
       result.filesCreated.push(readmePath);
       if (removeOriginals || itemSelections) {
         result.filesRemoved = [];
         for (const item of allItems) {
           const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
           const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0 && item.type !== "thread-endpoint" && item.type !== "effect";
-          if (shouldRemove && fs8.existsSync(item.filePath)) {
-            fs8.unlinkSync(item.filePath);
+          if (shouldRemove && fs9.existsSync(item.filePath)) {
+            fs9.unlinkSync(item.filePath);
             result.filesRemoved.push(item.filePath);
           }
         }
       }
-      const agentsDir = path8.join(rootDir, "agents");
+      const agentsDir = path9.join(rootDir, "agents");
       const metadataService = new MetadataService(agentsDir);
       const metadata = {
         packageName: finalPackageName,
@@ -4886,7 +4930,7 @@ var PackingService = class {
     const commonjs = (await import('@rollup/plugin-commonjs')).default;
     const esbuild = (await import('rollup-plugin-esbuild')).default;
     const externalDeps = /* @__PURE__ */ new Map();
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const resolveVersion = this.resolvePackageVersion.bind(this);
     const trackExternalsPlugin = {
       name: "track-externals",
@@ -4895,14 +4939,14 @@ var PackingService = class {
           return null;
         }
         if (source.startsWith("./") || source.startsWith("../")) {
-          const resolved = path8.resolve(path8.dirname(importer), source);
+          const resolved = path9.resolve(path9.dirname(importer), source);
           let tsResolved = resolved;
           if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-            if (fs8.existsSync(`${resolved}.ts`)) {
+            if (fs9.existsSync(`${resolved}.ts`)) {
               tsResolved = `${resolved}.ts`;
-            } else if (fs8.existsSync(`${resolved}.js`)) {
+            } else if (fs9.existsSync(`${resolved}.js`)) {
               tsResolved = `${resolved}.js`;
-            } else if (fs8.existsSync(`${resolved}/index.ts`)) {
+            } else if (fs9.existsSync(`${resolved}/index.ts`)) {
               tsResolved = `${resolved}/index.ts`;
             }
           }
@@ -4951,11 +4995,11 @@ var PackingService = class {
         exports: "named"
       });
       const bundledCode = output[0].code;
-      const header = `// Bundled from: ${path8.relative(rootDir, inputPath)}
+      const header = `// Bundled from: ${path9.relative(rootDir, inputPath)}
 // Local dependencies have been inlined
 
 `;
-      fs8.writeFileSync(outputPath, header + bundledCode);
+      fs9.writeFileSync(outputPath, header + bundledCode);
       await bundle.close();
     } catch (error) {
       await bundle.close();
@@ -5380,30 +5424,31 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Package info or null if not found
    */
   getPackedInfo(packageId, rootDir) {
-    const packedDir = path8.join(rootDir, "agents", "packed");
-    let packageDir = path8.join(packedDir, packageId);
-    if (!fs8.existsSync(packageDir)) {
-      if (!fs8.existsSync(packedDir)) {
+    const packedDir = path9.join(rootDir, "agents", "packed");
+    const safePackageId = assertSafePackageIdentifier(packageId);
+    let packageDir = resolvePathWithin(packedDir, safePackageId);
+    if (!fs9.existsSync(packageDir)) {
+      if (!fs9.existsSync(packedDir)) {
         return null;
       }
-      const dirs = fs8.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = fs9.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const matchingDir = dirs.find(
         (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
       );
       if (!matchingDir) {
         return null;
       }
-      packageDir = path8.join(packedDir, matchingDir);
+      packageDir = path9.join(packedDir, matchingDir);
     }
-    const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(packageDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
-    const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
     let readme;
-    const readmePath = path8.join(packageDir, "README.md");
-    if (fs8.existsSync(readmePath)) {
-      readme = fs8.readFileSync(readmePath, "utf-8");
+    const readmePath = path9.join(packageDir, "README.md");
+    if (fs9.existsSync(readmePath)) {
+      readme = fs9.readFileSync(readmePath, "utf-8");
     }
     return {
       packageName: pkgJson.name,
@@ -5421,11 +5466,11 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Array of package directory names
    */
   listPackedPackages(rootDir) {
-    const packedDir = path8.join(rootDir, "agents", "packed");
-    if (!fs8.existsSync(packedDir)) {
+    const packedDir = path9.join(rootDir, "agents", "packed");
+    if (!fs9.existsSync(packedDir)) {
       return [];
     }
-    return fs8.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs9.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   /**
    * Generate README.md content for a packed agent.
@@ -5472,17 +5517,17 @@ ${license || "See LICENSE file"}
    * Find a file by name in a directory.
    */
   async findFile(dir, name) {
-    if (!fs8.existsSync(dir)) {
+    if (!fs9.existsSync(dir)) {
       return null;
     }
-    const exactPath = path8.join(dir, `${name}.ts`);
-    if (fs8.existsSync(exactPath)) {
+    const exactPath = resolvePathWithin(dir, `${name}.ts`);
+    if (fs9.existsSync(exactPath)) {
       return exactPath;
     }
-    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    const files = fs9.readdirSync(dir).filter((f) => f.endsWith(".ts"));
     for (const file of files) {
-      const filePath = path8.join(dir, file);
-      const source = fs8.readFileSync(filePath, "utf-8");
+      const filePath = path9.join(dir, file);
+      const source = fs9.readFileSync(filePath, "utf-8");
       const extractedName = await extractDefinitionName(source);
       if (extractedName === name) {
         return filePath;
@@ -5494,15 +5539,15 @@ ${license || "See LICENSE file"}
    * List all agents in the workspace.
    */
   async listAgents(rootDir) {
-    const agentsDir = path8.join(rootDir, "agents", "agents");
-    if (!fs8.existsSync(agentsDir)) {
+    const agentsDir = path9.join(rootDir, "agents", "agents");
+    if (!fs9.existsSync(agentsDir)) {
       return [];
     }
-    const files = fs8.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const files = fs9.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
     const agents = [];
     for (const file of files) {
-      const filePath = path8.join(agentsDir, file);
-      const source = fs8.readFileSync(filePath, "utf-8");
+      const filePath = path9.join(agentsDir, file);
+      const source = fs9.readFileSync(filePath, "utf-8");
       const name = await extractDefinitionName(source);
       if (name) {
         agents.push(name);
@@ -5518,7 +5563,7 @@ var PackageDiscoveryService = class {
   constructor(config) {
     this.config = {
       rootDir: config.rootDir,
-      packedDir: config.packedDir ?? path8.join(config.rootDir, "agents", "packed"),
+      packedDir: config.packedDir ?? path9.join(config.rootDir, "agents", "packed"),
       scanNpm: config.scanNpm ?? true,
       scanLocal: config.scanLocal ?? true
     };
@@ -5551,19 +5596,19 @@ var PackageDiscoveryService = class {
    */
   async discoverNpmPackages() {
     const packages = [];
-    const nodeModulesDir = path8.join(this.config.rootDir, "node_modules");
-    if (!fs8.existsSync(nodeModulesDir)) {
+    const nodeModulesDir = path9.join(this.config.rootDir, "node_modules");
+    if (!fs9.existsSync(nodeModulesDir)) {
       return packages;
     }
     const rootEntries = await this.scanDirectory(nodeModulesDir);
     for (const entry of rootEntries) {
       if (entry.startsWith(".")) continue;
       if (entry.startsWith("@")) {
-        const scopeDir = path8.join(nodeModulesDir, entry);
+        const scopeDir = path9.join(nodeModulesDir, entry);
         const scopeEntries = await this.scanDirectory(scopeDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const pkgDir = path8.join(scopeDir, scopedPkg);
+          const pkgDir = path9.join(scopeDir, scopedPkg);
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkNpmPackage(pkgDir, fullName);
           if (pkg) {
@@ -5571,7 +5616,7 @@ var PackageDiscoveryService = class {
           }
         }
       } else {
-        const pkgDir = path8.join(nodeModulesDir, entry);
+        const pkgDir = path9.join(nodeModulesDir, entry);
         const pkg = await this.checkNpmPackage(pkgDir, entry);
         if (pkg) {
           packages.push(pkg);
@@ -5587,12 +5632,12 @@ var PackageDiscoveryService = class {
    * which must contain `entryAgents` array.
    */
   async checkNpmPackage(pkgDir, pkgName) {
-    const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(pkgDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       const isStandardAgent = (
         // Has "standardagent" keyword
         pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
@@ -5629,21 +5674,21 @@ var PackageDiscoveryService = class {
    */
   async discoverLocalPackages() {
     const packages = [];
-    if (!fs8.existsSync(this.config.packedDir)) {
+    if (!fs9.existsSync(this.config.packedDir)) {
       return packages;
     }
     const entries = await this.scanDirectory(this.config.packedDir);
     for (const entry of entries) {
       if (entry.startsWith(".")) continue;
-      const pkgDir = path8.join(this.config.packedDir, entry);
-      const stat = fs8.statSync(pkgDir);
+      const pkgDir = path9.join(this.config.packedDir, entry);
+      const stat = fs9.statSync(pkgDir);
       if (!stat.isDirectory()) continue;
       if (entry.startsWith("@")) {
         const scopeEntries = await this.scanDirectory(pkgDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const scopedPkgDir = path8.join(pkgDir, scopedPkg);
-          const scopedStat = fs8.statSync(scopedPkgDir);
+          const scopedPkgDir = path9.join(pkgDir, scopedPkg);
+          const scopedStat = fs9.statSync(scopedPkgDir);
           if (!scopedStat.isDirectory()) continue;
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
@@ -5666,12 +5711,12 @@ var PackageDiscoveryService = class {
    * Detection is based on the `standardagent` field in package.json.
    */
   async checkLocalPackage(pkgDir, dirName) {
-    const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(pkgDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
@@ -5696,10 +5741,10 @@ var PackageDiscoveryService = class {
    * Scan a directory and return entry names.
    */
   async scanDirectory(dir) {
-    if (!fs8.existsSync(dir)) {
+    if (!fs9.existsSync(dir)) {
       return [];
     }
-    const entries = fs8.readdirSync(dir);
+    const entries = fs9.readdirSync(dir);
     return entries;
   }
   /**
@@ -5792,29 +5837,29 @@ var UnpackingService = class {
       }
       analysis.version = pkg.version;
       analysis.source = pkg.source;
-      const indexPath = path8.join(pkg.path, "dist", "index.js");
-      if (!fs8.existsSync(indexPath)) {
+      const indexPath = path9.join(pkg.path, "dist", "index.js");
+      if (!fs9.existsSync(indexPath)) {
         analysis.errors.push(`Package index not found: ${indexPath}`);
         return analysis;
       }
-      const indexContent = fs8.readFileSync(indexPath, "utf-8");
+      const indexContent = fs9.readFileSync(indexPath, "utf-8");
       const registryItems = await this.parseIndexExports(indexContent);
       const availableItems = /* @__PURE__ */ new Map();
       for (const item of registryItems) {
         availableItems.set(`${item.type}:${item.name}`, item);
       }
-      const agentsDir = path8.join(rootDir, "agents");
+      const agentsDir = path9.join(rootDir, "agents");
       const itemsWithRelations = [];
       for (const item of registryItems) {
-        const targetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
-        const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const targetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
         const existsGlobally = this.fileExists(targetPath);
-        const sourceExists = fs8.existsSync(sourcePath);
+        const sourceExists = fs9.existsSync(sourcePath);
         if (!sourceExists) {
           analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
           continue;
         }
-        const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
+        const bundledCode = fs9.readFileSync(sourcePath, "utf-8");
         const children = await this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
         itemsWithRelations.push({
           name: item.name,
@@ -5824,10 +5869,10 @@ var UnpackingService = class {
           action: existsGlobally ? "skip" : "generate"
         });
         for (const child of children) {
-          const childTargetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
-          const childSourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childTargetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
           const childExists = this.fileExists(childTargetPath);
-          const childSourceExists = fs8.existsSync(childSourcePath);
+          const childSourceExists = fs9.existsSync(childSourcePath);
           if (!childSourceExists) {
             continue;
           }
@@ -5930,8 +5975,8 @@ var UnpackingService = class {
         return result;
       }
       const itemsToProcess = this.applySelections(analysis.items, itemSelections);
-      const pkgJsonPath = path8.join(pkg.path, "package.json");
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJsonPath = path9.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       let author = "";
       if (typeof pkgJson.author === "string") {
         author = pkgJson.author;
@@ -5956,18 +6001,19 @@ var UnpackingService = class {
           continue;
         }
         try {
-          const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
-          const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
+          const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const targetPath = resolvePathWithin(path9.join(rootDir, "agents"), path9.relative(path9.join(rootDir, "agents"), item.targetPath));
+          const bundledCode = fs9.readFileSync(sourcePath, "utf-8");
           let tsCode = await transformBundledJs(bundledCode);
           if (item.type === "agent") {
             tsCode = await injectAgentMetadata(tsCode, agentMetadata);
           }
-          const dir = path8.dirname(item.targetPath);
-          if (!fs8.existsSync(dir)) {
-            fs8.mkdirSync(dir, { recursive: true });
+          const dir = path9.dirname(targetPath);
+          if (!fs9.existsSync(dir)) {
+            fs9.mkdirSync(dir, { recursive: true });
           }
-          fs8.writeFileSync(item.targetPath, tsCode);
-          result.filesGenerated.push(item.targetPath);
+          fs9.writeFileSync(targetPath, tsCode);
+          result.filesGenerated.push(targetPath);
         } catch (error) {
           result.warnings.push(
             `Failed to generate ${item.type} "${item.name}": ${error instanceof Error ? error.message : String(error)}`
@@ -5976,7 +6022,12 @@ var UnpackingService = class {
       }
       if (deletePackage && pkg.source === "local") {
         try {
-          this.deleteDirectory(pkg.path);
+          const localPackedRoot = path9.join(rootDir, "agents", "packed");
+          const safePackagePath = resolvePathWithin(
+            localPackedRoot,
+            path9.relative(localPackedRoot, pkg.path)
+          );
+          this.deleteDirectory(safePackagePath);
           result.packageDeleted = true;
         } catch (error) {
           result.warnings.push(
@@ -6055,14 +6106,14 @@ var UnpackingService = class {
    */
   async resolvePackage(pkgIdentifier, rootDir) {
     if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
-      const absolutePath = path8.isAbsolute(pkgIdentifier) ? pkgIdentifier : path8.join(rootDir, pkgIdentifier);
-      const pkgJsonPath2 = path8.join(absolutePath, "package.json");
-      if (fs8.existsSync(pkgJsonPath2)) {
+      const absolutePath = path9.isAbsolute(pkgIdentifier) ? pkgIdentifier : path9.join(rootDir, pkgIdentifier);
+      const pkgJsonPath2 = path9.join(absolutePath, "package.json");
+      if (fs9.existsSync(pkgJsonPath2)) {
         try {
-          const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath2, "utf-8"));
+          const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath2, "utf-8"));
           if (pkgJson.standardagent?.entryAgents) {
             return {
-              packageId: pkgJson.name || path8.basename(absolutePath),
+              packageId: pkgJson.name || path9.basename(absolutePath),
               version: pkgJson.version || "0.0.0",
               source: "local",
               path: absolutePath,
@@ -6074,11 +6125,12 @@ var UnpackingService = class {
       }
       return null;
     }
-    const packedDir = path8.join(rootDir, "agents", "packed", pkgIdentifier);
-    const pkgJsonPath = path8.join(packedDir, "package.json");
-    if (fs8.existsSync(pkgJsonPath)) {
+    const safeIdentifier = assertSafePackageIdentifier(pkgIdentifier);
+    const packedDir = resolvePathWithin(path9.join(rootDir, "agents", "packed"), safeIdentifier);
+    const pkgJsonPath = path9.join(packedDir, "package.json");
+    if (fs9.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.standardagent?.entryAgents) {
           return {
             packageId: pkgJson.name || pkgIdentifier,
@@ -6119,18 +6171,18 @@ var UnpackingService = class {
    * Check if a file exists.
    */
   fileExists(filePath) {
-    if (fs8.existsSync(filePath)) {
+    if (fs9.existsSync(filePath)) {
       return true;
     }
     const withoutExt = filePath.replace(/\.(ts|js)$/, "");
-    return fs8.existsSync(`${withoutExt}.ts`) || fs8.existsSync(`${withoutExt}.js`);
+    return fs9.existsSync(`${withoutExt}.ts`) || fs9.existsSync(`${withoutExt}.js`);
   }
   /**
    * Recursively delete a directory.
    */
   deleteDirectory(dirPath) {
-    if (fs8.existsSync(dirPath)) {
-      fs8.rmSync(dirPath, { recursive: true, force: true });
+    if (fs9.existsSync(dirPath)) {
+      fs9.rmSync(dirPath, { recursive: true, force: true });
     }
   }
   /**
@@ -6206,8 +6258,8 @@ var NpmPublishService = class {
         error: "Registry URL must use HTTPS"
       };
     }
-    const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(packageDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return {
         success: false,
         output: "",
@@ -6217,7 +6269,7 @@ var NpmPublishService = class {
     let packageName;
     let version;
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       packageName = pkgJson.name;
       version = pkgJson.version;
     } catch (e) {
@@ -6227,13 +6279,13 @@ var NpmPublishService = class {
         error: `Failed to read package.json: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-    const npmrcPath = path8.join(packageDir, ".npmrc");
+    const npmrcPath = path9.join(packageDir, ".npmrc");
     const registryHost = new URL(registry).host;
     const npmrcContent = `//${registryHost}/:_authToken=${token}
 registry=${registry}
 `;
     try {
-      fs8.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
+      fs9.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
       const args = ["publish"];
       if (dryRun) {
         args.push("--dry-run");
@@ -6265,8 +6317,8 @@ registry=${registry}
       };
     } finally {
       try {
-        if (fs8.existsSync(npmrcPath)) {
-          fs8.unlinkSync(npmrcPath);
+        if (fs9.existsSync(npmrcPath)) {
+          fs9.unlinkSync(npmrcPath);
         }
       } catch {
       }
@@ -6359,7 +6411,7 @@ async function handlePackingApiRequest(context) {
       const body = await parseRequestBody(req);
       const packingService = new PackingService();
       const rootDir = process.cwd();
-      const outputDir = path8__default.join(rootDir, "agents", "packed");
+      const outputDir = path9__default.join(rootDir, "agents", "packed");
       const result = await packingService.pack({
         agentName,
         rootDir,
@@ -6412,8 +6464,8 @@ async function handlePackingApiRequest(context) {
         res.end(JSON.stringify({ error: "Cannot delete npm packages. Use npm uninstall instead." }));
         return true;
       }
-      const fs18 = await import('fs');
-      fs18.rmSync(pkg.path, { recursive: true, force: true });
+      const fs19 = await import('fs');
+      fs19.rmSync(pkg.path, { recursive: true, force: true });
       await reloadAllAgentModules(context);
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
@@ -6441,8 +6493,8 @@ async function handlePackingApiRequest(context) {
         return true;
       }
       const { spawn } = await import('child_process');
-      const parentDir = path8__default.dirname(pkg.path);
-      const dirName = path8__default.basename(pkg.path);
+      const parentDir = path9__default.dirname(pkg.path);
+      const dirName = path9__default.basename(pkg.path);
       res.setHeader("Content-Type", "application/gzip");
       res.setHeader("Content-Disposition", `attachment; filename="${packageId}.tar.gz"`);
       const tar = spawn("tar", ["-czf", "-", "-C", parentDir, dirName]);
@@ -6496,18 +6548,19 @@ async function handlePackingApiRequest(context) {
   if (packPublishMatch && method === "POST") {
     try {
       const packageId = decodeURIComponent(packPublishMatch[1]);
+      assertSafePackageIdentifier(packageId);
       const body = await parseRequestBody(req);
       const rootDir = process.cwd();
-      const packedDir = path8__default.join(rootDir, "agents", "packed");
-      let packageDir = path8__default.join(packedDir, packageId);
-      if (!fs8__default.existsSync(packageDir)) {
-        if (!fs8__default.existsSync(packedDir)) {
+      const packedDir = path9__default.join(rootDir, "agents", "packed");
+      let packageDir = resolvePathWithin(packedDir, packageId);
+      if (!fs9__default.existsSync(packageDir)) {
+        if (!fs9__default.existsSync(packedDir)) {
           res.statusCode = 400;
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify({ error: "No packed packages found. Pack the agent first." }));
           return true;
         }
-        const dirs = fs8__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        const dirs = fs9__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
         const matchingDir = dirs.find(
           (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
         );
@@ -6519,14 +6572,14 @@ async function handlePackingApiRequest(context) {
           }));
           return true;
         }
-        packageDir = path8__default.join(packedDir, matchingDir);
+        packageDir = resolvePathWithin(packedDir, matchingDir);
       }
       let token = body.token || process.env.NPM_TOKEN;
       let tokenSource = body.token ? "provided" : "environment";
       if (!token) {
-        const devVarsPath = path8__default.join(rootDir, ".dev.vars");
-        if (fs8__default.existsSync(devVarsPath)) {
-          const devVars = fs8__default.readFileSync(devVarsPath, "utf-8");
+        const devVarsPath = path9__default.join(rootDir, ".dev.vars");
+        if (fs9__default.existsSync(devVarsPath)) {
+          const devVars = fs9__default.readFileSync(devVarsPath, "utf-8");
           const match = devVars.match(/^NPM_TOKEN=(.+)$/m);
           if (match) {
             token = match[1].trim();
@@ -6637,27 +6690,67 @@ async function handlePackingApiRequest(context) {
   return false;
 }
 
+// src/routing/access-policy.ts
+function isProviderIconRoute(routePath) {
+  return /^\/api\/providers\/[^/]+\/icon$/.test(routePath);
+}
+function isHostedInstance(env) {
+  const value = env?.STANDARD_AGENTS_HOSTED;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "0" && normalized !== "false";
+  }
+  return Boolean(value);
+}
+function isTrustedLocalDevelopmentRequest(request, env) {
+  if (isHostedInstance(env)) return false;
+  let hostname;
+  try {
+    hostname = new URL(request.url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
+}
+function isAdminOnlyApiRoute(routePath, method = "GET") {
+  if (routePath === "/api/skills" || routePath.startsWith("/api/skills/")) return true;
+  if (routePath === "/api/pack" || routePath.startsWith("/api/pack/")) return true;
+  if (routePath === "/api/unpack" || routePath.startsWith("/api/unpack/")) return true;
+  if (routePath === "/api/prompts" || routePath.startsWith("/api/prompts/")) return true;
+  if (routePath === "/api/tools" || routePath.startsWith("/api/tools/")) return true;
+  if (routePath === "/api/models" || routePath.startsWith("/api/models/")) return true;
+  if (routePath === "/api/providers") return true;
+  if (routePath.startsWith("/api/providers/")) {
+    return !isProviderIconRoute(routePath);
+  }
+  if (routePath.startsWith("/api/agents/")) {
+    return !/^\/api\/agents\/[^/]+\/tenvs$/.test(routePath);
+  }
+  if (routePath === "/api/agents" && method.toUpperCase() !== "GET") return true;
+  return false;
+}
+
 // src/plugin/dev-middleware.ts
 function readRawRequestBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
     req.on("end", () => {
-      resolve2(chunks.length > 0 ? Buffer.concat(chunks) : void 0);
+      resolve3(chunks.length > 0 ? Buffer.concat(chunks) : void 0);
     });
     req.on("error", reject);
   });
 }
 function resolveContainedFile(baseDir, requestPath) {
-  const resolvedBase = path8__default.resolve(baseDir);
-  const resolved = path8__default.resolve(resolvedBase, `.${path8__default.sep}${requestPath.replace(/^\/+/, "")}`);
-  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path8__default.sep)) {
+  const resolvedBase = path9__default.resolve(baseDir);
+  const resolved = path9__default.resolve(resolvedBase, `.${path9__default.sep}${requestPath.replace(/^\/+/, "")}`);
+  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path9__default.sep)) {
     return null;
   }
   try {
-    return fs8__default.existsSync(resolved) && fs8__default.statSync(resolved).isFile() ? resolved : null;
+    return fs9__default.existsSync(resolved) && fs9__default.statSync(resolved).isFile() ? resolved : null;
   } catch {
     return null;
   }
@@ -6707,6 +6800,21 @@ function createDevMiddleware(server, context) {
         return;
       }
     }
+    const routePath = new URL(pathWithoutMount, "http://localhost").pathname;
+    let trustedLocalHost = false;
+    try {
+      trustedLocalHost = isTrustedLocalDevelopmentRequest(
+        new Request(`http://${req.headers.host || "invalid.remote"}${routePath}`),
+        {}
+      );
+    } catch {
+    }
+    if (isAdminOnlyApiRoute(routePath, method) && !trustedLocalHost) {
+      res.statusCode = 403;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Authoring APIs are available only from local development hosts" }));
+      return;
+    }
     if (await handleConfigApiRequest({
       req,
       res,
@@ -6796,19 +6904,19 @@ function createDevMiddleware(server, context) {
     const clientPath = pathWithoutMount.startsWith("/agents/") ? pathWithoutMount.slice("/agents".length) || "/" : pathWithoutMount;
     const isStaticAsset = clientPath.startsWith("/assets/") || clientPath.startsWith("/vendor.js") || clientPath.startsWith("/vue.js") || clientPath.startsWith("/monaco.js") || clientPath.startsWith("/index.js") || clientPath.startsWith("/index.css") || clientPath.match(/\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico)$/);
     {
-      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
+      const currentDir = path9__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path8__default.resolve(
+      const clientDir = path9__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
       let filePath;
       if (isStaticAsset) {
         const cleanUrl = clientPath.split("?")[0];
-        filePath = path8__default.join(clientDir, cleanUrl);
-        if (!fs8__default.existsSync(filePath)) {
+        filePath = path9__default.join(clientDir, cleanUrl);
+        if (!fs9__default.existsSync(filePath)) {
           const projectPublicFile = resolveContainedFile(
-            path8__default.resolve(server.config.root, "public"),
+            path9__default.resolve(server.config.root, "public"),
             cleanUrl
           );
           if (projectPublicFile) {
@@ -6816,12 +6924,12 @@ function createDevMiddleware(server, context) {
           }
         }
       } else {
-        filePath = path8__default.join(clientDir, "index.html");
+        filePath = path9__default.join(clientDir, "index.html");
       }
       try {
-        if (fs8__default.existsSync(filePath)) {
-          let content = fs8__default.readFileSync(filePath);
-          const ext = path8__default.extname(filePath).toLowerCase();
+        if (fs9__default.existsSync(filePath)) {
+          let content = fs9__default.readFileSync(filePath);
+          const ext = path9__default.extname(filePath).toLowerCase();
           if (ext === ".html") {
             content = Buffer.from(
               injectUiConfigIntoHtml(content.toString())
@@ -6861,7 +6969,7 @@ async function loadBuilderVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path9__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -7133,7 +7241,7 @@ async function loadRegistryVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path9__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -7161,23 +7269,23 @@ async function loadRegistryVirtualModule(context) {
     const absPath = toAbsolutePath(importPath);
     return `    "${name}": async () => (await import("${absPath}")).default,`;
   }).join("\n");
-  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
   const packedPackages = [];
-  if (fs8__default.existsSync(packedDir)) {
+  if (fs9__default.existsSync(packedDir)) {
     console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
     const packageDirs = discoverPackedPackageDirectories(packedDir);
     console.log(`[vite-plugin-agent] Found package dirs: ${packageDirs.join(", ")}`);
     for (const pkgPath of packageDirs) {
-      const pkgJsonPath = path8__default.join(pkgPath, "package.json");
-      if (fs8__default.existsSync(pkgJsonPath)) {
+      const pkgJsonPath = path9__default.join(pkgPath, "package.json");
+      if (fs9__default.existsSync(pkgJsonPath)) {
         try {
-          const pkgJson = JSON.parse(fs8__default.readFileSync(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(fs9__default.readFileSync(pkgJsonPath, "utf-8"));
           console.log(`[vite-plugin-agent] Loaded ${pkgPath} package.json, standardagent:`, pkgJson.standardagent);
           if (!pkgJson.standardagent) {
             continue;
           }
           const mainEntry = pkgJson.main || "./dist/index.js";
-          const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+          const outputDir = path9__default.dirname(mainEntry).replace(/^\.\//, "");
           const pkg = {
             packageId: pkgJson.name,
             version: pkgJson.version,
@@ -7295,7 +7403,7 @@ export function getVisibleToolNames() {
 async function loadRoutesVirtualModule(context) {
   const { threadApiDir, rou3Code, hmr } = context;
   const threadRoutes = scanApiDirectory(threadApiDir);
-  const toAbsolutePath = (inputPath) => path8__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
+  const toAbsolutePath = (inputPath) => path9__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
   const threadRouteCode = threadRoutes.map(({ method, route, importPath }) => {
     const apiRoute = `/api/threads/:threadId${route}`;
     return `  addRoute(
@@ -7306,20 +7414,20 @@ async function loadRoutesVirtualModule(context) {
   );`;
   }).join("\n");
   const packedThreadRoutes = [];
-  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
   const packedPackageDirs = discoverPackedPackageDirectories(packedDir);
   for (const packagePath of packedPackageDirs) {
-    const packageJsonPath = path8__default.join(packagePath, "package.json");
-    if (!fs8__default.existsSync(packageJsonPath)) {
+    const packageJsonPath = path9__default.join(packagePath, "package.json");
+    if (!fs9__default.existsSync(packageJsonPath)) {
       continue;
     }
     try {
-      const packageJson = JSON.parse(fs8__default.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs9__default.readFileSync(packageJsonPath, "utf-8"));
       if (!packageJson.standardagent) {
         continue;
       }
       const mainEntry = packageJson.main || "./dist/index.js";
-      const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+      const outputDir = path9__default.dirname(mainEntry).replace(/^\.\//, "");
       const threadEndpoints = scanPackedThreadEndpoints(packagePath, outputDir);
       for (const endpoint of threadEndpoints) {
         const apiRoute = `/api/threads/:threadId${endpoint.route}`;
@@ -7353,98 +7461,16 @@ import { providers, providerNames, providerFactories } from "virtual:@standardag
 import { prompts, promptNames } from "virtual:@standardagents-prompts";
 import { agents, agentNames } from "virtual:@standardagents-agents";
 import { registry } from "virtual:@standardagents-registry";
-import { requireAuth, createThreadEndpointHandler } from "@standardagents/builder/runtime";
+import {
+  requireAuth,
+  createThreadEndpointHandler,
+  canAccessThread,
+  isHostedInstance,
+  isPublicApiRoute,
+  isAdminOnlyApiRoute,
+} from "@standardagents/builder/runtime";
 import { isThreadEndpoint } from "@standardagents/spec";
 
-// Routes that don't require authentication
-const PUBLIC_ROUTES = [
-  '/api/auth/bootstrap',
-  '/api/auth/login',
-  '/api/auth/config',
-  '/api/auth/brolly-control',
-  '/api/auth/platform-cleanup',
-  '/api/auth/platform-replica',
-  '/api/auth/sa/start',     // Login with Standard Agents (OAuth) \u2014 unauthenticated entry
-  '/api/auth/sa/callback',  // OAuth callback (sets the session cookie)
-  '/api/config',
-  '/api/auth/oauth/github',
-  '/api/auth/oauth/google',
-  '/api/auth/oauth/github/callback',
-  '/api/auth/oauth/google/callback',
-  '/api/platform-auth/bootstrap',
-  '/api/platform-auth/login',
-  '/api/platform-auth/logout',
-  '/api/platform-auth/me',
-  '/api/hooks'  // Hook metadata is safe to expose publicly
-];
-
-// True when the platform deployed this instance (injects STANDARD_AGENTS_HOSTED).
-// Hosted instances are internet-reachable and multi-tenant, so the thread data
-// API and event/stream WebSockets must NOT be anonymously public the way they
-// are in single-user local dev \u2014 they require a session (admin) or API key (SDK).
-function isHostedInstance(env) {
-  const value = env && env.STANDARD_AGENTS_HOSTED;
-  if (typeof value === 'string') {
-    const trimmed = value.trim().toLowerCase();
-    return trimmed !== '' && trimmed !== '0' && trimmed !== 'false';
-  }
-  return Boolean(value);
-}
-
-// Check if a route is public (no auth required)
-function isPublicRoute(routePath, hosted) {
-  // Exact match for auth routes
-  if (PUBLIC_ROUTES.includes(routePath)) {
-    return true;
-  }
-
-  // Thread routes (REST + message/log stream WebSockets) are public in local
-  // single-user dev, but on a hosted deployment they require auth \u2014 requireAuth
-  // accepts the admin's session (cookie or token) or the SDK's API key, so this
-  // only blocks anonymous access to another tenant's threads/messages/files.
-  if (!hosted && (routePath.startsWith('/api/threads/') || routePath === '/api/threads')) {
-    return true;
-  }
-
-  // Device-code CLI login: start/poll are public by design (possession of the
-  // one-time code is the secret) and the approve page must reach its controller
-  // even when anonymous so it can redirect the browser through the platform
-  // login (the controller enforces session auth itself).
-  if (routePath === '/api/auth/device/start' || routePath.startsWith('/api/auth/device/')) {
-    return true;
-  }
-
-  // Provider icon routes are public (used by <img src>)
-  if (routePath.startsWith('/api/providers/') && routePath.includes('/icon')) {
-    return true;
-  }
-
-  // Platform proxy routes handle their own auth in local dev only.
-  if (hosted && (routePath.startsWith('/api/platform/') || routePath === '/api/platform')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform/') || routePath === '/api/platform') {
-    return true;
-  }
-
-  // Platform session proxy and auth bridge are local-dev helpers only.
-  if (hosted && (routePath.startsWith('/api/platform-session/') || routePath === '/api/platform-session')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform-session/') || routePath === '/api/platform-session') {
-    return true;
-  }
-
-  if (hosted && (routePath.startsWith('/api/platform-auth/') || routePath === '/api/platform-auth')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform-auth/') || routePath === '/api/platform-auth') {
-    return true;
-  }
-
-  return false;
-}
-
 function platformEndpoint(env) {
   const configured =
     env && (env.PLATFORM_ENDPOINT || env.STANDARD_AGENTS_PLATFORM_URL || env.PLATFORM_URL || env.STANDARD_AGENTS_PUBLIC_URL);
@@ -7587,7 +7613,7 @@ ${packedThreadRouteCode}
 
   if (routeMatch) {
     // Check if authentication is required for this route
-    const publicRoute = isPublicRoute(routePath, isHostedInstance(env));
+    const publicRoute = isPublicApiRoute(routePath, request, env);
     const isApiRoute = routePath.startsWith('/api/');
 
     let authContext = null;
@@ -7603,6 +7629,10 @@ ${packedThreadRouteCode}
 
       authContext = authResult;
 
+      if (isAdminOnlyApiRoute(routePath, request.method) && authContext.user.role !== 'admin') {
+        return addCorsHeaders(Response.json({ error: 'Forbidden: Admin access required' }, { status: 403 }));
+      }
+
       if (routePath.startsWith('/api/threads/')) {
         // Packed and user thread endpoints reserve threadId for the owning
         // thread while nested endpoint parameters may also be named id.
@@ -7616,7 +7646,7 @@ ${packedThreadRouteCode}
           if (!thread) {
             return addCorsHeaders(Response.json({ error: \`Thread not found: \${threadId}\` }, { status: 404 }));
           }
-          if (authContext.user.role !== 'admin' && (thread.user_id === null || thread.user_id !== authContext.user.id)) {
+          if (!canAccessThread(authContext, thread)) {
             return addCorsHeaders(Response.json({ error: "Forbidden: You don't have access to this thread" }, { status: 403 }));
           }
         }
@@ -7792,13 +7822,13 @@ ${hooksCode}
 };`;
   }
   if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
-    const relativeToolsDir = path8__default.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
-    const relativeHooksDir = path8__default.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
-    const relativeApiDir = path8__default.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
-    const relativeModelsDir = path8__default.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
-    const relativeProvidersDir = path8__default.relative(process.cwd(), providersDir).replace(/\\/g, "/");
-    const relativePromptsDir = path8__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
-    const relativeAgentsDir = path8__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
+    const relativeToolsDir = path9__default.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
+    const relativeHooksDir = path9__default.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
+    const relativeApiDir = path9__default.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
+    const relativeModelsDir = path9__default.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
+    const relativeProvidersDir = path9__default.relative(process.cwd(), providersDir).replace(/\\/g, "/");
+    const relativePromptsDir = path9__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
+    const relativeAgentsDir = path9__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
     return `// Virtual agent config module
 export const config = {
   toolsDir: "${relativeToolsDir}",
@@ -8015,14 +8045,14 @@ var packingDeps = [
   "typescript"
 ];
 function createPluginViteConfig(pluginModuleUrl) {
-  const currentDir = path8__default.dirname(fileURLToPath(pluginModuleUrl));
+  const currentDir = path9__default.dirname(fileURLToPath(pluginModuleUrl));
   const isInDist = currentDir.endsWith("dist");
-  const builderClientDir = path8__default.resolve(
+  const builderClientDir = path9__default.resolve(
     currentDir,
     isInDist ? "./client" : "../dist/client"
   );
   return {
-    publicDir: fs8__default.existsSync(builderClientDir) ? builderClientDir : void 0,
+    publicDir: fs9__default.existsSync(builderClientDir) ? builderClientDir : void 0,
     build: {
       rollupOptions: {
         external: [...packingDeps]
@@ -8169,24 +8199,24 @@ function applyPluginEnvironmentConfig(config) {
 
 // src/plugin.ts
 function agentbuilder(options = {}) {
-  const toolsDir = options.toolsDir ? path8__default.resolve(process.cwd(), options.toolsDir) : path8__default.resolve(process.cwd(), "agents/tools");
-  const hooksDir = options.hooksDir ? path8__default.resolve(process.cwd(), options.hooksDir) : path8__default.resolve(process.cwd(), "agents/hooks");
-  const threadApiDir = options.apiDir ? path8__default.resolve(process.cwd(), options.apiDir) : path8__default.resolve(process.cwd(), "agents/api");
-  const modelsDir = options.modelsDir ? path8__default.resolve(process.cwd(), options.modelsDir) : path8__default.resolve(process.cwd(), "agents/models");
-  const providersDir = options.providersDir ? path8__default.resolve(process.cwd(), options.providersDir) : path8__default.resolve(process.cwd(), "agents/providers");
-  const promptsDir = options.promptsDir ? path8__default.resolve(process.cwd(), options.promptsDir) : path8__default.resolve(process.cwd(), "agents/prompts");
-  const agentsDir = options.agentsDir ? path8__default.resolve(process.cwd(), options.agentsDir) : path8__default.resolve(process.cwd(), "agents/agents");
-  const effectsDir = options.effectsDir ? path8__default.resolve(process.cwd(), options.effectsDir) : path8__default.resolve(process.cwd(), "agents/effects");
-  const usersDir = options.usersDir ? path8__default.resolve(process.cwd(), options.usersDir) : path8__default.resolve(process.cwd(), "agents/users");
-  const outputDir = path8__default.resolve(process.cwd(), ".agents");
-  const generatedWorkerEntry = path8__default.join(outputDir, "worker.ts");
+  const toolsDir = options.toolsDir ? path9__default.resolve(process.cwd(), options.toolsDir) : path9__default.resolve(process.cwd(), "agents/tools");
+  const hooksDir = options.hooksDir ? path9__default.resolve(process.cwd(), options.hooksDir) : path9__default.resolve(process.cwd(), "agents/hooks");
+  const threadApiDir = options.apiDir ? path9__default.resolve(process.cwd(), options.apiDir) : path9__default.resolve(process.cwd(), "agents/api");
+  const modelsDir = options.modelsDir ? path9__default.resolve(process.cwd(), options.modelsDir) : path9__default.resolve(process.cwd(), "agents/models");
+  const providersDir = options.providersDir ? path9__default.resolve(process.cwd(), options.providersDir) : path9__default.resolve(process.cwd(), "agents/providers");
+  const promptsDir = options.promptsDir ? path9__default.resolve(process.cwd(), options.promptsDir) : path9__default.resolve(process.cwd(), "agents/prompts");
+  const agentsDir = options.agentsDir ? path9__default.resolve(process.cwd(), options.agentsDir) : path9__default.resolve(process.cwd(), "agents/agents");
+  const effectsDir = options.effectsDir ? path9__default.resolve(process.cwd(), options.effectsDir) : path9__default.resolve(process.cwd(), "agents/effects");
+  const usersDir = options.usersDir ? path9__default.resolve(process.cwd(), options.usersDir) : path9__default.resolve(process.cwd(), "agents/users");
+  const outputDir = path9__default.resolve(process.cwd(), ".agents");
+  const generatedWorkerEntry = path9__default.join(outputDir, "worker.ts");
   const isProviderPackageInstalled = (packageName) => {
     let dir = process.cwd();
     for (; ; ) {
-      if (fs8__default.existsSync(path8__default.join(dir, "node_modules", packageName, "package.json"))) {
+      if (fs9__default.existsSync(path9__default.join(dir, "node_modules", packageName, "package.json"))) {
         return true;
       }
-      const parent = path8__default.dirname(dir);
+      const parent = path9__default.dirname(dir);
       if (parent === dir) return false;
       dir = parent;
     }
@@ -8221,17 +8251,17 @@ export default {
 
 export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog, DurableUserHub };
 `;
-    fs8__default.mkdirSync(outputDir, { recursive: true });
-    if (!fs8__default.existsSync(generatedWorkerEntry) || fs8__default.readFileSync(generatedWorkerEntry, "utf-8") !== content) {
-      fs8__default.writeFileSync(generatedWorkerEntry, content);
+    fs9__default.mkdirSync(outputDir, { recursive: true });
+    if (!fs9__default.existsSync(generatedWorkerEntry) || fs9__default.readFileSync(generatedWorkerEntry, "utf-8") !== content) {
+      fs9__default.writeFileSync(generatedWorkerEntry, content);
     }
   }
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path8__default.dirname(__filename);
-  const rou3Path = path8__default.join(__dirname, "../dist/rou3.js");
+  const __dirname = path9__default.dirname(__filename);
+  const rou3Path = path9__default.join(__dirname, "../dist/rou3.js");
   let rou3Code = "";
   try {
-    rou3Code = fs8__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+    rou3Code = fs9__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
   } catch (err) {
     console.warn("[vite-plugin-agent] Could not read rou3.js for inlining:", err);
   }
@@ -8274,7 +8304,7 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     sourceDirs,
     regenerateTypes
   };
-  const workerEntry = path8__default.relative(process.cwd(), generatedWorkerEntry).split(path8__default.sep).join("/");
+  const workerEntry = path9__default.relative(process.cwd(), generatedWorkerEntry).split(path9__default.sep).join("/");
   const corePlugin = {
     name: "vite-plugin-agent",
     enforce: "pre",
@@ -8349,28 +8379,28 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     },
     writeBundle(options2, bundle) {
       const outDir = options2.dir || "dist";
-      const mountDir = path8__default.join(outDir, "../client");
-      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
+      const mountDir = path9__default.join(outDir, "../client");
+      const currentDir = path9__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path8__default.resolve(
+      const clientDir = path9__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
-      if (!fs8__default.existsSync(clientDir)) {
+      if (!fs9__default.existsSync(clientDir)) {
         console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
         return;
       }
-      fs8__default.mkdirSync(mountDir, { recursive: true });
+      fs9__default.mkdirSync(mountDir, { recursive: true });
       function copyRecursive(src, dest) {
-        const entries = fs8__default.readdirSync(src, { withFileTypes: true });
+        const entries = fs9__default.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const srcPath = path8__default.join(src, entry.name);
-          const destPath = path8__default.join(dest, entry.name);
+          const srcPath = path9__default.join(src, entry.name);
+          const destPath = path9__default.join(dest, entry.name);
           if (entry.isDirectory()) {
-            fs8__default.mkdirSync(destPath, { recursive: true });
+            fs9__default.mkdirSync(destPath, { recursive: true });
             copyRecursive(srcPath, destPath);
           } else {
-            let content = fs8__default.readFileSync(srcPath);
+            let content = fs9__default.readFileSync(srcPath);
             if (entry.name === "index.html") {
               const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = {};</script>`;
               let htmlContent = content.toString();
@@ -8378,27 +8408,27 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs8__default.writeFileSync(destPath, content);
+            fs9__default.writeFileSync(destPath, content);
           }
         }
       }
       copyRecursive(clientDir, mountDir);
-      const projectPublicDir = path8__default.resolve(process.cwd(), "public");
-      if (fs8__default.existsSync(projectPublicDir)) {
+      const projectPublicDir = path9__default.resolve(process.cwd(), "public");
+      if (fs9__default.existsSync(projectPublicDir)) {
         let copyPublicRecursive2 = function(src, dest) {
-          const entries = fs8__default.readdirSync(src, { withFileTypes: true });
+          const entries = fs9__default.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const srcPath = path8__default.join(src, entry.name);
-            const destPath = path8__default.join(dest, entry.name);
+            const srcPath = path9__default.join(src, entry.name);
+            const destPath = path9__default.join(dest, entry.name);
             if (entry.isDirectory()) {
-              fs8__default.mkdirSync(destPath, { recursive: true });
+              fs9__default.mkdirSync(destPath, { recursive: true });
               copyPublicRecursive2(srcPath, destPath);
-            } else if (fs8__default.existsSync(destPath)) {
+            } else if (fs9__default.existsSync(destPath)) {
               console.warn(
                 `[agentbuilder] Skipping public/ file that collides with a built UI asset: ${destPath}`
               );
             } else {
-              fs8__default.copyFileSync(srcPath, destPath);
+              fs9__default.copyFileSync(srcPath, destPath);
             }
           }
         };