@standardagents/builder 0.11.12 → 0.12.1

package/dist/plugin.js

@@ -1,6 +1,12 @@
-import fs2 from 'fs';
-import path3 from 'path';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import * as path8 from 'path';
+import path8__default from 'path';
 import { fileURLToPath } from 'url';
+import * as ts from 'typescript';
+import MagicString from 'magic-string';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 
 // src/plugin.ts
 var TSCONFIG_CONTENT = `{
@@ -35,15 +41,15 @@ function extractSchemaFields(content) {
 }
 function scanPromptsWithSchemas(dir) {
   const results = [];
-  if (!fs2.existsSync(dir)) {
+  if (!fs2__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path3.join(dir, entry.name);
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs2__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -59,15 +65,15 @@ function scanPromptsWithSchemas(dir) {
 }
 function scanAgentsWithSideA(dir) {
   const results = [];
-  if (!fs2.existsSync(dir)) {
+  if (!fs2__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path3.join(dir, entry.name);
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs2__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -87,15 +93,15 @@ function scanAgentsWithSideA(dir) {
 }
 function scanForNames(dir, useFilename = false) {
   const names = [];
-  if (!fs2.existsSync(dir)) {
+  if (!fs2__default.existsSync(dir)) {
     return names;
   }
   try {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path3.join(dir, entry.name);
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs2__default.readFileSync(filePath, "utf-8");
         if (useFilename) {
           const toolName = entry.name.replace(/\.ts$/, "");
           if (content.includes("defineTool")) {
@@ -114,6 +120,31 @@ function scanForNames(dir, useFilename = false) {
   }
   return names;
 }
+function scanHooksForIds(dir) {
+  const hookIds = [];
+  if (!fs2__default.existsSync(dir)) {
+    return hookIds;
+  }
+  try {
+    const entries = fs2__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 = fs2__default.readFileSync(filePath, "utf-8");
+        const idMatch = content.match(/defineHook\s*\(\s*\{[^}]*id:\s*['"]([^'"]+)['"]/s);
+        if (idMatch) {
+          hookIds.push(idMatch[1]);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error scanning hooks directory ${dir}:`, error);
+  }
+  return hookIds;
+}
 function generateRegistryProperties(names) {
   if (names.length === 0) {
     return "";
@@ -150,6 +181,7 @@ function generateTypesContent(config) {
   const promptResults = scanPromptsWithSchemas(config.promptsDir);
   const agentResults = scanAgentsWithSideA(config.agentsDir);
   const tools = scanForNames(config.toolsDir, true);
+  const hookIds = scanHooksForIds(config.hooksDir);
   const prompts = promptResults.map((p) => p.name);
   const agents = agentResults.map((a) => a.name);
   const callables = [...prompts, ...agents, ...tools];
@@ -157,11 +189,11 @@ function generateTypesContent(config) {
 // Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
 //
 // This file augments the StandardAgentSpec namespace declared in @standardagents/spec
-// to provide type-safe references for your models, prompts, agents, and tools.
+// to provide type-safe references for your models, prompts, agents, tools, and hooks.
 
 /**
  * Augment the global StandardAgentSpec namespace with your project's specific types.
- * This provides autocomplete and type checking for model, prompt, agent, and tool references.
+ * This provides autocomplete and type checking for model, prompt, agent, tool, and hook references.
  *
  * Uses interface declaration merging with property keys to create union types.
  * Example: interface ModelRegistry { 'gpt-4o': true; } gives type Models = 'gpt-4o'
@@ -193,6 +225,11 @@ declare global {
       ${generateRegistryProperties(callables)}
     }
 
+    /** Hook IDs from agents/hooks/ */
+    interface HookIdRegistry {
+      ${generateRegistryProperties(hookIds)}
+    }
+
     /** Schema field names for prompts and agents (used for initUserMessageProperty autocomplete) */
     interface PromptSchemaRegistry {
       ${generateSchemaRegistryProperties(promptResults, agentResults)}
@@ -643,35 +680,35 @@ declare module 'virtual:@standardagents/router' {
 `;
 }
 function ensureDir(dir) {
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  if (!fs2__default.existsSync(dir)) {
+    fs2__default.mkdirSync(dir, { recursive: true });
   }
 }
 function generateTypes(config) {
   ensureDir(config.outputDir);
   const typesContent = generateTypesContent(config);
-  fs2.writeFileSync(path3.join(config.outputDir, "types.d.ts"), typesContent);
+  fs2__default.writeFileSync(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
   const virtualModuleContent = generateVirtualModuleContent();
-  fs2.writeFileSync(path3.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
-  fs2.writeFileSync(path3.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
-  fs2.writeFileSync(path3.join(config.outputDir, ".gitignore"), "*\n");
+  fs2__default.writeFileSync(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  fs2__default.writeFileSync(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  fs2__default.writeFileSync(path8__default.join(config.outputDir, ".gitignore"), "*\n");
 }
 function needsRegeneration(config) {
-  const typesPath = path3.join(config.outputDir, "types.d.ts");
-  if (!fs2.existsSync(typesPath)) {
+  const typesPath = path8__default.join(config.outputDir, "types.d.ts");
+  if (!fs2__default.existsSync(typesPath)) {
     return true;
   }
-  const typesMtime = fs2.statSync(typesPath).mtime;
-  const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir];
+  const typesMtime = fs2__default.statSync(typesPath).mtime;
+  const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir, config.hooksDir];
   for (const dir of dirs) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs2__default.existsSync(dir)) {
       continue;
     }
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path3.join(dir, entry.name);
-        const fileMtime = fs2.statSync(filePath).mtime;
+        const filePath = path8__default.join(dir, entry.name);
+        const fileMtime = fs2__default.statSync(filePath).mtime;
         if (fileMtime > typesMtime) {
           return true;
         }
@@ -681,81 +718,6 @@ function needsRegeneration(config) {
   return false;
 }
 
-// src/utils/model-parser.ts
-function getName(content) {
-  return content.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
-}
-function getProvider(content) {
-  const stringMatch = content.match(/provider:\s*['"]([^'"]+)['"]/)?.[1];
-  if (stringMatch) return stringMatch;
-  const refMatch = content.match(/provider:\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*[,\n}]/)?.[1];
-  return refMatch || void 0;
-}
-function getModel(content) {
-  return content.match(/model:\s*['"]([^'"]+)['"]/)?.[1];
-}
-function getInputPrice(content) {
-  const match = content.match(/inputPrice:\s*([\d.]+)/);
-  return match ? parseFloat(match[1]) : void 0;
-}
-function getOutputPrice(content) {
-  const match = content.match(/outputPrice:\s*([\d.]+)/);
-  return match ? parseFloat(match[1]) : void 0;
-}
-function getCachedPrice(content) {
-  const match = content.match(/cachedPrice:\s*([\d.]+)/);
-  return match ? parseFloat(match[1]) : void 0;
-}
-function getIncludedProviders(content) {
-  const match = content.match(/includedProviders:\s*\[([^\]]*)\]/);
-  if (!match) return void 0;
-  const items = match[1].match(/['"]([^'"]+)['"]/g);
-  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
-}
-function getFallbacks(content) {
-  const match = content.match(/fallbacks:\s*\[([^\]]*)\]/);
-  if (!match) return [];
-  const items = match[1].match(/['"]([^'"]+)['"]/g);
-  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
-}
-function getProviderTools(content) {
-  const match = content.match(/providerTools:\s*\[([^\]]*)\]/);
-  if (!match) return [];
-  const items = match[1].match(/['"]([^'"]+)['"]/g);
-  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
-}
-function getCapabilities(content) {
-  const match = content.match(/capabilities:\s*\{([^}]*)\}/s);
-  if (!match) return void 0;
-  const inner = match[1];
-  const caps = {};
-  const boolMatches = inner.matchAll(/(\w+):\s*(true|false)/g);
-  for (const m of boolMatches) {
-    caps[m[1]] = m[2] === "true";
-  }
-  const numMatches = inner.matchAll(/(\w+):\s*(\d+)/g);
-  for (const m of numMatches) {
-    caps[m[1]] = parseInt(m[2], 10);
-  }
-  return Object.keys(caps).length > 0 ? caps : void 0;
-}
-function parseModelFile(content) {
-  const name = getName(content);
-  if (!name) return null;
-  return {
-    name,
-    provider: getProvider(content),
-    model: getModel(content),
-    inputPrice: getInputPrice(content),
-    outputPrice: getOutputPrice(content),
-    cachedPrice: getCachedPrice(content),
-    includedProviders: getIncludedProviders(content),
-    fallbacks: getFallbacks(content),
-    providerTools: getProviderTools(content),
-    capabilities: getCapabilities(content)
-  };
-}
-
 // src/sdk/generators/generateModelFile.ts
 function generateModelFile(data, options) {
   const { providerName, providerPackage } = options;
@@ -1189,6 +1151,18 @@ function generateAgentFile(data) {
     `export default defineAgent({`,
     `  name: '${escapeString3(data.name)}',`
   ];
+  if (data.packageName) {
+    lines.push(`  packageName: '${escapeString3(data.packageName)}',`);
+  }
+  if (data.version) {
+    lines.push(`  version: '${escapeString3(data.version)}',`);
+  }
+  if (data.author) {
+    lines.push(`  author: '${escapeString3(data.author)}',`);
+  }
+  if (data.license) {
+    lines.push(`  license: '${escapeString3(data.license)}',`);
+  }
   if (data.title) {
     lines.push(`  title: '${escapeString3(data.title)}',`);
   }
@@ -1236,7 +1210,7 @@ function formatSideConfig(config) {
   if (config.endSessionTool) {
     parts.push(`    endSessionTool: '${escapeString3(config.endSessionTool)}',`);
   }
-  if (config.manualStopCondition !== void 0) {
+  if (config.manualStopCondition) {
     parts.push(`    manualStopCondition: ${config.manualStopCondition},`);
   }
   parts.push("  }");
@@ -1259,19 +1233,19 @@ function nameToFilename(name) {
 }
 function getModelFilePath(modelsDir, name) {
   const filename = nameToFilename(name);
-  return path3.join(modelsDir, `${filename}.ts`);
+  return path8__default.join(modelsDir, `${filename}.ts`);
 }
 function modelExists(modelsDir, name) {
   const filePath = getModelFilePath(modelsDir, name);
-  return fs2.existsSync(filePath);
+  return fs2__default.existsSync(filePath);
 }
 async function saveModel(modelsDir, data, overwrite = false) {
   try {
-    if (!fs2.existsSync(modelsDir)) {
-      fs2.mkdirSync(modelsDir, { recursive: true });
+    if (!fs2__default.existsSync(modelsDir)) {
+      fs2__default.mkdirSync(modelsDir, { recursive: true });
     }
     const filePath = getModelFilePath(modelsDir, data.name);
-    if (!overwrite && fs2.existsSync(filePath)) {
+    if (!overwrite && fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file already exists: ${filePath}. Use update to modify existing models.`
@@ -1288,7 +1262,7 @@ async function saveModel(modelsDir, data, overwrite = false) {
       providerName: providerInfo.name,
       providerPackage: providerInfo.package
     });
-    await fs2.promises.writeFile(filePath, content, "utf-8");
+    await fs2__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1303,13 +1277,13 @@ async function saveModel(modelsDir, data, overwrite = false) {
 async function deleteModel(modelsDir, name) {
   try {
     const filePath = getModelFilePath(modelsDir, name);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file not found: ${filePath}`
       };
     }
-    await fs2.promises.unlink(filePath);
+    await fs2__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1348,6 +1322,9 @@ function validateModelData(data) {
   if (!data.name || typeof data.name !== "string") {
     return "Model name is required and must be a string";
   }
+  if (data.name.includes("/")) {
+    return "Model name cannot contain '/'. Reserved for namespace qualification.";
+  }
   if (!data.provider || typeof data.provider !== "string") {
     return "Model provider is required and must be a string";
   }
@@ -1436,26 +1413,26 @@ function transformPromptData(data) {
 }
 function getPromptFilePath(promptsDir, name) {
   const filename = nameToFilename(name);
-  return path3.join(promptsDir, `${filename}.ts`);
+  return path8__default.join(promptsDir, `${filename}.ts`);
 }
 function promptExists(promptsDir, name) {
   const filePath = getPromptFilePath(promptsDir, name);
-  return fs2.existsSync(filePath);
+  return fs2__default.existsSync(filePath);
 }
 async function savePrompt(promptsDir, data, overwrite = false) {
   try {
-    if (!fs2.existsSync(promptsDir)) {
-      fs2.mkdirSync(promptsDir, { recursive: true });
+    if (!fs2__default.existsSync(promptsDir)) {
+      fs2__default.mkdirSync(promptsDir, { recursive: true });
     }
     const filePath = getPromptFilePath(promptsDir, data.name);
-    if (!overwrite && fs2.existsSync(filePath)) {
+    if (!overwrite && fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
       };
     }
     const content = generatePromptFile(data);
-    await fs2.promises.writeFile(filePath, content, "utf-8");
+    await fs2__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1470,13 +1447,13 @@ async function savePrompt(promptsDir, data, overwrite = false) {
 async function deletePrompt(promptsDir, name) {
   try {
     const filePath = getPromptFilePath(promptsDir, name);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${filePath}`
       };
     }
-    await fs2.promises.unlink(filePath);
+    await fs2__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1492,25 +1469,25 @@ async function renamePrompt(promptsDir, oldName, newName) {
   try {
     const oldFilePath = getPromptFilePath(promptsDir, oldName);
     const newFilePath = getPromptFilePath(promptsDir, newName);
-    if (!fs2.existsSync(oldFilePath)) {
+    if (!fs2__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${oldFilePath}`
       };
     }
-    if (fs2.existsSync(newFilePath)) {
+    if (fs2__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${newFilePath}`
       };
     }
-    const content = await fs2.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs2__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs2.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs2.promises.unlink(oldFilePath);
+    await fs2__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs2__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -1526,6 +1503,9 @@ function validatePromptData(data) {
   if (!data.name || typeof data.name !== "string") {
     return "Prompt name is required and must be a string";
   }
+  if (data.name.includes("/")) {
+    return "Prompt name cannot contain '/'. Reserved for namespace qualification.";
+  }
   if (!data.model || typeof data.model !== "string") {
     return "Prompt model is required and must be a string";
   }
@@ -1639,26 +1619,58 @@ function transformAgentData(data) {
 }
 function getAgentFilePath(agentsDir, name) {
   const filename = nameToFilename(name);
-  return path3.join(agentsDir, `${filename}.ts`);
+  return path8__default.join(agentsDir, `${filename}.ts`);
 }
 function agentExists(agentsDir, name) {
   const filePath = getAgentFilePath(agentsDir, name);
-  return fs2.existsSync(filePath);
+  return fs2__default.existsSync(filePath);
+}
+function extractAgentMetadata(filePath) {
+  try {
+    const content = fs2__default.readFileSync(filePath, "utf-8");
+    const metadata = {};
+    const packageNameMatch = content.match(/packageName:\s*['"]([^'"]+)['"]/);
+    if (packageNameMatch) metadata.packageName = packageNameMatch[1];
+    const versionMatch = content.match(/version:\s*['"]([^'"]+)['"]/);
+    if (versionMatch) metadata.version = versionMatch[1];
+    const authorMatch = content.match(/author:\s*['"]([^'"]+)['"]/);
+    if (authorMatch) metadata.author = authorMatch[1];
+    const licenseMatch = content.match(/license:\s*['"]([^'"]+)['"]/);
+    if (licenseMatch) metadata.license = licenseMatch[1];
+    return metadata;
+  } catch {
+    return {};
+  }
 }
 async function saveAgent(agentsDir, data, overwrite = false) {
   try {
-    if (!fs2.existsSync(agentsDir)) {
-      fs2.mkdirSync(agentsDir, { recursive: true });
+    if (!fs2__default.existsSync(agentsDir)) {
+      fs2__default.mkdirSync(agentsDir, { recursive: true });
     }
     const filePath = getAgentFilePath(agentsDir, data.name);
-    if (!overwrite && fs2.existsSync(filePath)) {
+    if (!overwrite && fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
       };
     }
+    if (overwrite && fs2__default.existsSync(filePath)) {
+      const existingMetadata = extractAgentMetadata(filePath);
+      if (existingMetadata.packageName && !data.packageName) {
+        data.packageName = existingMetadata.packageName;
+      }
+      if (existingMetadata.version && !data.version) {
+        data.version = existingMetadata.version;
+      }
+      if (existingMetadata.author && !data.author) {
+        data.author = existingMetadata.author;
+      }
+      if (existingMetadata.license && !data.license) {
+        data.license = existingMetadata.license;
+      }
+    }
     const content = generateAgentFile(data);
-    await fs2.promises.writeFile(filePath, content, "utf-8");
+    await fs2__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1673,13 +1685,13 @@ async function saveAgent(agentsDir, data, overwrite = false) {
 async function deleteAgent(agentsDir, name) {
   try {
     const filePath = getAgentFilePath(agentsDir, name);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs2__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file not found: ${filePath}`
       };
     }
-    await fs2.promises.unlink(filePath);
+    await fs2__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -1695,25 +1707,25 @@ async function renameModel(modelsDir, oldName, newName) {
   try {
     const oldFilePath = getModelFilePath(modelsDir, oldName);
     const newFilePath = getModelFilePath(modelsDir, newName);
-    if (!fs2.existsSync(oldFilePath)) {
+    if (!fs2__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Model file not found: ${oldFilePath}`
       };
     }
-    if (fs2.existsSync(newFilePath)) {
+    if (fs2__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Model file already exists: ${newFilePath}`
       };
     }
-    const content = await fs2.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs2__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs2.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs2.promises.unlink(oldFilePath);
+    await fs2__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs2__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -1727,17 +1739,17 @@ async function renameModel(modelsDir, oldName, newName) {
 }
 async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
   const updatedFiles = [];
-  if (!fs2.existsSync(promptsDir)) {
+  if (!fs2__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs2.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs2__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path3.join(promptsDir, file);
-    let content = await fs2.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(promptsDir, file);
+    let content = await fs2__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 fs2.promises.writeFile(filePath, content, "utf-8");
+      await fs2__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1745,13 +1757,13 @@ async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModel
 }
 async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs2.existsSync(promptsDir)) {
+  if (!fs2__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs2.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs2__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path3.join(promptsDir, file);
-    let content = await fs2.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(promptsDir, file);
+    let content = await fs2__default.promises.readFile(filePath, "utf-8");
     let modified = false;
     const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
     const newContent = content.replace(toolsArrayRegex, (match) => {
@@ -1764,7 +1776,7 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
       return replaced;
     });
     if (modified) {
-      await fs2.promises.writeFile(filePath, newContent, "utf-8");
+      await fs2__default.promises.writeFile(filePath, newContent, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1772,17 +1784,17 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
 }
 async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs2.existsSync(agentsDir)) {
+  if (!fs2__default.existsSync(agentsDir)) {
     return updatedFiles;
   }
-  const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs2__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path3.join(agentsDir, file);
-    let content = await fs2.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(agentsDir, file);
+    let content = await fs2__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 fs2.promises.writeFile(filePath, content, "utf-8");
+      await fs2__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -1795,6 +1807,9 @@ function validateAgentData(data) {
   if (!data.name || typeof data.name !== "string") {
     return "Agent name is required and must be a string";
   }
+  if (data.name.includes("/")) {
+    return "Agent name cannot contain '/'. Reserved for namespace qualification.";
+  }
   if (data.title !== void 0 && typeof data.title !== "string") {
     return "Agent title must be a string if provided";
   }
@@ -1853,166 +1868,2528 @@ function validateAgentData(data) {
   }
   return null;
 }
-
-// src/plugin.ts
-var VIRTUAL_TOOLS_ID = "virtual:@standardagents-tools";
-var RESOLVED_VIRTUAL_TOOLS_ID = "\0" + VIRTUAL_TOOLS_ID;
-var VIRTUAL_ROUTES_ID = "virtual:@standardagents-routes";
-var RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
-var VIRTUAL_ROUTER_ID = "virtual:@standardagents/router";
-var RESOLVED_VIRTUAL_ROUTER_ID = "\0" + VIRTUAL_ROUTER_ID;
-var VIRTUAL_HOOKS_ID = "virtual:@standardagents-hooks";
-var RESOLVED_VIRTUAL_HOOKS_ID = "\0" + VIRTUAL_HOOKS_ID;
-var VIRTUAL_CONFIG_ID = "virtual:@standardagents-config";
-var RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
-var VIRTUAL_THREAD_API_ID = "virtual:@standardagents-thread-api";
-var RESOLVED_VIRTUAL_THREAD_API_ID = "\0" + VIRTUAL_THREAD_API_ID;
-var VIRTUAL_MODELS_ID = "virtual:@standardagents-models";
-var RESOLVED_VIRTUAL_MODELS_ID = "\0" + VIRTUAL_MODELS_ID;
-var VIRTUAL_PROMPTS_ID = "virtual:@standardagents-prompts";
-var RESOLVED_VIRTUAL_PROMPTS_ID = "\0" + VIRTUAL_PROMPTS_ID;
-var VIRTUAL_AGENTS_ID = "virtual:@standardagents-agents";
-var RESOLVED_VIRTUAL_AGENTS_ID = "\0" + VIRTUAL_AGENTS_ID;
-var VIRTUAL_EFFECTS_ID = "virtual:@standardagents-effects";
-var RESOLVED_VIRTUAL_EFFECTS_ID = "\0" + VIRTUAL_EFFECTS_ID;
-var VIRTUAL_PROVIDERS_ID = "virtual:@standardagents-providers";
-var RESOLVED_VIRTUAL_PROVIDERS_ID = "\0" + VIRTUAL_PROVIDERS_ID;
-var VIRTUAL_BUILDER_ID = "virtual:@standardagents/builder";
-var RESOLVED_VIRTUAL_BUILDER_ID = "\0" + VIRTUAL_BUILDER_ID;
-function scanApiDirectory(dir, baseRoute = "") {
-  const routes = [];
-  if (!fs2.existsSync(dir)) {
-    return routes;
+var MetadataService = class {
+  metadataDir;
+  /**
+   * Create a new MetadataService.
+   *
+   * @param agentsDir - Path to the agents/ directory
+   */
+  constructor(agentsDir) {
+    this.metadataDir = path8.join(agentsDir, ".standardagent");
   }
-  try {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const convertedDirName = entry.name.replace(/\[([^\]]+)\]/g, ":$1");
-        const subRoute = baseRoute + "/" + convertedDirName;
-        routes.push(...scanApiDirectory(fullPath, subRoute));
-      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const fileName = entry.name.replace(/\.ts$/, "");
-        let method = "";
-        let routePath = baseRoute;
-        if (fileName.includes(".")) {
-          const parts = fileName.split(".");
-          const methodPart = parts[parts.length - 1].toUpperCase();
-          if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(methodPart)) {
-            method = methodPart;
-            const pathPart = parts.slice(0, -1).join(".");
-            if (pathPart !== "index") {
-              const convertedPath = pathPart.replace(/\[([^\]]+)\]/g, ":$1");
-              routePath += "/" + convertedPath;
-            }
-          } else {
-            if (fileName !== "index") {
-              const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
-              routePath += "/" + convertedPath;
+  /**
+   * Read metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   * @returns Metadata if found, null otherwise
+   */
+  async read(agentName) {
+    const filePath = this.getMetadataPath(agentName);
+    if (!fs2.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   * @param metadata - Metadata to write
+   */
+  async write(agentName, metadata) {
+    if (!fs2.existsSync(this.metadataDir)) {
+      fs2.mkdirSync(this.metadataDir, { recursive: true });
+    }
+    const filePath = this.getMetadataPath(agentName);
+    fs2.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+  }
+  /**
+   * Delete metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   */
+  async delete(agentName) {
+    const filePath = this.getMetadataPath(agentName);
+    if (fs2.existsSync(filePath)) {
+      fs2.unlinkSync(filePath);
+    }
+  }
+  /**
+   * Get the next version by incrementing the patch number.
+   *
+   * @param currentVersion - Current semver version (e.g., "1.0.0")
+   * @returns Incremented version (e.g., "1.0.1")
+   */
+  getNextVersion(currentVersion) {
+    const parts = currentVersion.split(".");
+    if (parts.length < 3) {
+      return `${currentVersion}.1`;
+    }
+    const patchPart = parts[2];
+    const prereleaseIndex = patchPart.indexOf("-");
+    if (prereleaseIndex > -1) {
+      const patch2 = parseInt(patchPart.substring(0, prereleaseIndex), 10);
+      const prerelease = patchPart.substring(prereleaseIndex);
+      return `${parts[0]}.${parts[1]}.${patch2 + 1}${prerelease}`;
+    }
+    const patch = parseInt(patchPart, 10);
+    return `${parts[0]}.${parts[1]}.${patch + 1}`;
+  }
+  /**
+   * Validate a semver version string.
+   *
+   * @param version - Version string to validate
+   * @returns true if valid semver format
+   */
+  isValidVersion(version) {
+    const semverPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+    return semverPattern.test(version);
+  }
+  /**
+   * Validate an npm package name.
+   *
+   * @param name - Package name to validate
+   * @returns Object with valid flag and optional error message
+   */
+  validatePackageName(name) {
+    if (!name) {
+      return { valid: false, error: "Package name is required" };
+    }
+    if (name.length > 214) {
+      return { valid: false, error: "Package name must be 214 characters or less" };
+    }
+    if (name.startsWith(".") || name.startsWith("_")) {
+      return { valid: false, error: "Package name cannot start with . or _" };
+    }
+    if (name !== name.toLowerCase()) {
+      return { valid: false, error: "Package name must be lowercase" };
+    }
+    const validPattern = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+    if (!validPattern.test(name)) {
+      return {
+        valid: false,
+        error: "Package name can only contain lowercase letters, numbers, hyphens, underscores, and dots"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Generate a suggested package name from project ID and agent name.
+   *
+   * @param projectId - Project identifier (optional)
+   * @param agentName - Agent name
+   * @returns Suggested npm package name
+   */
+  suggestPackageName(projectId, agentName) {
+    const normalizedAgent = agentName.toLowerCase().replace(/_/g, "-");
+    if (projectId) {
+      const normalizedProject = projectId.toLowerCase().replace(/_/g, "-");
+      return `standardagent-${normalizedProject}-${normalizedAgent}`;
+    }
+    return `standardagent-${normalizedAgent}`;
+  }
+  /**
+   * Get the file path for an agent's metadata.
+   */
+  getMetadataPath(agentName) {
+    return path8.join(this.metadataDir, `${agentName}.json`);
+  }
+};
+function extractToolUses(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "tool.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {
+    uses: [],
+    found: false
+  };
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineTool" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "uses" && ts.isArrayLiteralExpression(prop.initializer)) {
+          result.found = true;
+          result.line = sourceFile.getLineAndCharacterOfPosition(prop.getStart()).line + 1;
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              result.uses.push(element.text);
             }
           }
-        } else {
-          if (fileName !== "index") {
-            const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
-            routePath += "/" + convertedPath;
-          }
         }
-        const importPath = "./" + path3.relative(process.cwd(), fullPath).replace(/\\/g, "/");
-        routes.push({
-          method,
-          route: routePath || "/",
-          importPath
-        });
       }
     }
-    return routes;
-  } catch (error) {
-    console.error(`Error scanning API directory ${dir}:`, error);
-    return [];
+    ts.forEachChild(node, visit);
   }
+  visit(sourceFile);
+  return result;
 }
-function isSnakeCase(str) {
-  return /^[a-z][a-z0-9_]*[a-z0-9]$/.test(str) || /^[a-z]$/.test(str);
+function extractPromptTools(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {
+    tools: [],
+    hasSubpromptConfigs: false
+  };
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "tools" && ts.isArrayLiteralExpression(prop.initializer)) {
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              result.tools.push(element.text);
+            } else if (ts.isObjectLiteralExpression(element)) {
+              result.hasSubpromptConfigs = true;
+              for (const objProp of element.properties) {
+                if (ts.isPropertyAssignment(objProp) && ts.isIdentifier(objProp.name) && objProp.name.text === "name" && ts.isStringLiteral(objProp.initializer)) {
+                  result.tools.push(objProp.initializer.text);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
 }
-function validateToolFile(filePath, fileName) {
-  try {
-    const content = fs2.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()`;
+function extractPromptModel(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let model = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "model" && ts.isStringLiteral(prop.initializer)) {
+          model = prop.initializer.text;
+        }
+      }
     }
-    return null;
-  } catch (error) {
-    return `Failed to read tool file '${fileName}.ts'`;
+    ts.forEachChild(node, visit);
   }
+  visit(sourceFile);
+  return model;
 }
-async function scanToolsDirectory(dir) {
-  const tools = [];
-  if (!fs2.existsSync(dir)) {
-    return tools;
+function extractPromptIncludes(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const includes = [];
+  function extractFromStructuredPrompt(arr) {
+    for (const element of arr.elements) {
+      if (ts.isObjectLiteralExpression(element)) {
+        let hasIncludeType = false;
+        let includeName = null;
+        for (const prop of element.properties) {
+          if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === "type" && ts.isStringLiteral(prop.initializer) && prop.initializer.text === "include") {
+              hasIncludeType = true;
+            }
+            if (prop.name.text === "name" && ts.isStringLiteral(prop.initializer)) {
+              includeName = prop.initializer.text;
+            }
+          }
+        }
+        if (hasIncludeType && includeName && !includes.includes(includeName)) {
+          includes.push(includeName);
+        }
+      }
+    }
   }
-  const entries = await fs2.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 = path3.join(dir, entry.name);
-      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
-      let toolError;
-      const validationError = validateToolFile(filePath, fileName);
-      if (validationError) {
-        toolError = validationError;
-        console.error(`
-\u274C Tool validation error: ${validationError}`);
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          if (prop.name.text === "prompt" && ts.isArrayLiteralExpression(prop.initializer)) {
+            extractFromStructuredPrompt(prop.initializer);
+          }
+          if (prop.name.text === "includes" && ts.isArrayLiteralExpression(prop.initializer)) {
+            for (const element of prop.initializer.elements) {
+              if (ts.isStringLiteral(element) && !includes.includes(element.text)) {
+                includes.push(element.text);
+              }
+            }
+          }
+        }
       }
-      if (!isSnakeCase(fileName)) {
-        const warning = `Tool name should be in snake_case format (e.g., 'log_name', 'send_email')`;
-        if (toolError) {
-          toolError += ` | ${warning}`;
-        } else {
-          toolError = warning;
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return includes;
+}
+function extractAgentPrompts(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {};
+  function extractPromptFromSide(obj) {
+    for (const prop of obj.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "prompt" && ts.isStringLiteral(prop.initializer)) {
+        return prop.initializer.text;
+      }
+    }
+    return void 0;
+  }
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          if (prop.name.text === "sideA" && ts.isObjectLiteralExpression(prop.initializer)) {
+            result.sideA = extractPromptFromSide(prop.initializer);
+          }
+          if (prop.name.text === "sideB" && ts.isObjectLiteralExpression(prop.initializer)) {
+            result.sideB = extractPromptFromSide(prop.initializer);
+          }
         }
-        console.warn(
-          `
-\u26A0\uFE0F  Tool naming warning: '${fileName}' should be in snake_case format (e.g., 'log_name', 'send_email')`
-        );
       }
-      tools.push({ name: fileName, importPath, error: toolError });
     }
+    ts.forEachChild(node, visit);
   }
-  return tools;
+  visit(sourceFile);
+  return result;
 }
-async function scanHooksDirectory(dir) {
-  const hooks = [];
-  if (!fs2.existsSync(dir)) {
-    return hooks;
+function extractAgentDescription(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let description = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "description" && ts.isStringLiteral(prop.initializer)) {
+          description = prop.initializer.text;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
   }
-  const entries = await fs2.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;
+  visit(sourceFile);
+  return description;
+}
+function extractDefinitionName(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "def.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let name = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && (node.expression.text === "defineTool" || node.expression.text === "definePrompt" || node.expression.text === "defineAgent" || node.expression.text === "defineModel" || node.expression.text === "defineHook") && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "name" && ts.isStringLiteral(prop.initializer)) {
+          name = prop.initializer.text;
+        }
       }
-      const filePath = path3.join(dir, entry.name);
-      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
-      hooks.push({ name: fileName, importPath });
     }
+    ts.forEachChild(node, visit);
   }
-  return hooks;
+  visit(sourceFile);
+  return name;
 }
-async function scanConfigDirectory(dir, definePattern) {
-  const items = [];
-  if (!fs2.existsSync(dir)) {
-    return items;
+function extractModelFallbacks(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "model.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const fallbacks = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineModel" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "fallbacks" && ts.isArrayLiteralExpression(prop.initializer)) {
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              fallbacks.push(element.text);
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
   }
-  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const filePath = path3.join(dir, entry.name);
-      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
+  visit(sourceFile);
+  return fallbacks;
+}
+function transformBundledJs(code) {
+  const s = new MagicString(code);
+  const sourceFile = ts.createSourceFile(
+    "file.js",
+    code,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let firstImportStart = -1;
+  let varStatementInfo = null;
+  function visit(node) {
+    if (ts.isImportDeclaration(node) && firstImportStart === -1) {
+      firstImportStart = node.getStart();
+    }
+    if (ts.isVariableStatement(node)) {
+      const decl = node.declarationList.declarations[0];
+      if (decl && decl.initializer && ts.isCallExpression(decl.initializer)) {
+        const callExpr = decl.initializer.expression;
+        if (ts.isIdentifier(callExpr) && (callExpr.text === "defineAgent" || callExpr.text === "definePrompt" || callExpr.text === "defineTool" || callExpr.text === "defineModel" || callExpr.text === "defineHook")) {
+          varStatementInfo = {
+            fullStart: node.getFullStart(),
+            start: node.getStart(),
+            varNameEnd: decl.initializer.getStart()
+          };
+          s.overwrite(varStatementInfo.start, varStatementInfo.varNameEnd, "export default ");
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      const exportClause = node.exportClause;
+      if (exportClause && ts.isNamedExports(exportClause)) {
+        for (const element of exportClause.elements) {
+          if (element.propertyName && ts.isIdentifier(element.name) && element.name.text === "default") {
+            s.remove(node.getFullStart(), node.getEnd());
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (firstImportStart > 0) {
+    s.remove(0, firstImportStart);
+  }
+  return s.toString().trim() + "\n";
+}
+function injectAgentMetadata(tsCode, metadata) {
+  if (!metadata.packageName && !metadata.version && !metadata.author && !metadata.license) {
+    return tsCode;
+  }
+  const s = new MagicString(tsCode);
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    tsCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "name") {
+          const metadataProps = [];
+          if (metadata.packageName) {
+            metadataProps.push(`packageName: ${JSON.stringify(metadata.packageName)}`);
+          }
+          if (metadata.version) {
+            metadataProps.push(`version: ${JSON.stringify(metadata.version)}`);
+          }
+          if (metadata.author) {
+            metadataProps.push(`author: ${JSON.stringify(metadata.author)}`);
+          }
+          if (metadata.license) {
+            metadataProps.push(`license: ${JSON.stringify(metadata.license)}`);
+          }
+          if (metadataProps.length > 0) {
+            const propEnd = prop.getEnd();
+            const afterProp = tsCode.substring(propEnd, propEnd + 1);
+            if (afterProp === ",") {
+              const insertText = `
+  ${metadataProps.join(",\n  ")},`;
+              s.appendRight(propEnd + 1, insertText);
+            } else {
+              const insertText = `,
+  ${metadataProps.join(",\n  ")}`;
+              s.appendRight(propEnd, insertText);
+            }
+          }
+          return;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return s.toString();
+}
+
+// src/packing/packing-service.ts
+var PackingService = class {
+  /**
+   * Resolve the version of an npm package from node_modules.
+   *
+   * @param pkgName - Package name (e.g., '@standardagents/spec')
+   * @param rootDir - Root directory of the project
+   * @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");
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      return `^${pkgJson.version}`;
+    } catch {
+      return "*";
+    }
+  }
+  /**
+   * Analyze an agent to discover all its constituents.
+   *
+   * This performs static analysis on the agent definition and all
+   * referenced prompts, tools, models, and hooks.
+   *
+   * @param agentName - Name of the agent to analyze
+   * @param rootDir - Root directory of the agents workspace
+   * @returns Analysis result with all discovered constituents
+   */
+  async analyzeAgent(agentName, rootDir) {
+    const agentsDir = path8.join(rootDir, "agents");
+    const analysis = {
+      agent: agentName,
+      primaryPrompt: "",
+      constituents: {
+        prompts: [],
+        tools: [],
+        models: [],
+        hooks: [],
+        agents: []
+      },
+      shared: {
+        prompts: [],
+        tools: [],
+        models: [],
+        hooks: []
+      },
+      warnings: [],
+      errors: []
+    };
+    const agentFilePath = this.findFile(path8.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) {
+      analysis.errors.push(`Agent file not found: ${agentName}`);
+      return analysis;
+    }
+    analysis.constituents.agents.push({
+      name: agentName,
+      filePath: agentFilePath,
+      discoveredVia: "static",
+      sharedWith: []
+    });
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    if (agentPrompts.sideA) {
+      analysis.primaryPrompt = agentPrompts.sideA;
+      await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
+    }
+    if (agentPrompts.sideB) {
+      await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
+    }
+    await this.checkSharedItems(agentsDir, analysis);
+    return analysis;
+  }
+  /**
+   * Generate a README for an analyzed agent.
+   *
+   * This is used during analysis to provide a pre-populated README
+   * that can be edited in the PackModal before packing.
+   *
+   * @param analysis - The packing analysis result
+   * @param rootDir - Root directory of the project
+   * @returns Object with generatedReadme and agentDescription
+   */
+  generateReadmeForAnalysis(analysis, rootDir) {
+    const agentsDir = path8.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 = fs2.readFileSync(agentItem.filePath, "utf-8");
+        agentDescription = extractAgentDescription(agentSource) || void 0;
+      } catch {
+      }
+    }
+    const suggestedPackageName = metadataService.suggestPackageName(void 0, analysis.agent);
+    const generatedReadme = this.generateReadme(
+      suggestedPackageName,
+      analysis.agent,
+      "1.0.0",
+      // Default version, will be replaced in modal
+      "MIT",
+      // Default license
+      agentDescription
+    );
+    return { generatedReadme, agentDescription };
+  }
+  /**
+   * Recursively analyze a prompt and its dependencies.
+   */
+  async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
+    const promptFilePath = this.findFile(path8.join(agentsDir, "prompts"), promptName);
+    if (!promptFilePath) {
+      analysis.warnings.push(`Prompt file not found: ${promptName}`);
+      return;
+    }
+    const thisKey = `prompt:${promptName}`;
+    if (!analysis.constituents.prompts.some((p) => p.name === promptName && p.parentKey === parentKey)) {
+      analysis.constituents.prompts.push({
+        name: promptName,
+        filePath: promptFilePath,
+        discoveredVia: "agent-prompt",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`prompt:${promptName}`)) {
+      return;
+    }
+    visited.add(`prompt:${promptName}`);
+    const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+    const modelName = extractPromptModel(promptSource);
+    if (modelName) {
+      await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
+    }
+    const { tools: toolNames } = extractPromptTools(promptSource);
+    for (const toolName of toolNames) {
+      await this.analyzeTool(toolName, agentsDir, analysis, visited, "prompt-tools", thisKey);
+    }
+    const includedPrompts = extractPromptIncludes(promptSource);
+    for (const includedPrompt of includedPrompts) {
+      const item = analysis.constituents.prompts.find((p) => p.name === includedPrompt);
+      if (item) {
+        if (item.discoveredVia === "agent-prompt") {
+          item.discoveredVia = "prompt-includes";
+        }
+      }
+      await this.analyzePrompt(includedPrompt, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Analyze a tool and its dependencies.
+   * This also handles prompts-as-tools and agents-as-tools (handoffs).
+   */
+  async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
+    const thisKey = `tool:${toolName}`;
+    const promptFilePath = this.findFile(path8.join(agentsDir, "prompts"), toolName);
+    if (promptFilePath) {
+      await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
+      return;
+    }
+    const agentFilePath = this.findFile(path8.join(agentsDir, "agents"), toolName);
+    if (agentFilePath) {
+      await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
+      return;
+    }
+    const toolFilePath = this.findFile(path8.join(agentsDir, "tools"), toolName);
+    if (!toolFilePath) {
+      analysis.warnings.push(`Tool file not found: ${toolName}`);
+      return;
+    }
+    if (!analysis.constituents.tools.some((t) => t.name === toolName && t.parentKey === parentKey)) {
+      analysis.constituents.tools.push({
+        name: toolName,
+        filePath: toolFilePath,
+        discoveredVia,
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`tool:${toolName}`)) {
+      return;
+    }
+    visited.add(`tool:${toolName}`);
+    const toolSource = fs2.readFileSync(toolFilePath, "utf-8");
+    const { uses } = extractToolUses(toolSource);
+    for (const usedItem of uses) {
+      await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
+    }
+  }
+  /**
+   * Analyze a nested agent (used as a handoff target).
+   */
+  async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
+    const agentFilePath = this.findFile(path8.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) {
+      analysis.warnings.push(`Agent file not found: ${agentName}`);
+      return;
+    }
+    const thisKey = `agent:${agentName}`;
+    if (!analysis.constituents.agents.some((a) => a.name === agentName && a.parentKey === parentKey)) {
+      analysis.constituents.agents.push({
+        name: agentName,
+        filePath: agentFilePath,
+        discoveredVia: "uses",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`agent:${agentName}`)) {
+      return;
+    }
+    visited.add(`agent:${agentName}`);
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    if (agentPrompts.sideA) {
+      await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
+    }
+    if (agentPrompts.sideB) {
+      await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Analyze a model and its fallbacks.
+   */
+  async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
+    const modelFilePath = this.findFile(path8.join(agentsDir, "models"), modelName);
+    if (!modelFilePath) {
+      analysis.warnings.push(`Model file not found: ${modelName}`);
+      return;
+    }
+    const thisKey = `model:${modelName}`;
+    if (!analysis.constituents.models.some((m) => m.name === modelName && m.parentKey === parentKey)) {
+      analysis.constituents.models.push({
+        name: modelName,
+        filePath: modelFilePath,
+        discoveredVia: "static",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`model:${modelName}`)) {
+      return;
+    }
+    visited.add(`model:${modelName}`);
+    const modelSource = fs2.readFileSync(modelFilePath, "utf-8");
+    const fallbacks = extractModelFallbacks(modelSource);
+    for (const fallbackName of fallbacks) {
+      await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Check which items are shared with other agents.
+   */
+  async checkSharedItems(agentsDir, analysis) {
+    const agentsPath = path8.join(agentsDir, "agents");
+    if (!fs2.existsSync(agentsPath)) return;
+    const agentFiles = fs2.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));
+      for (const prompt of analysis.constituents.prompts) {
+        if (otherAnalysis.prompts.includes(prompt.name)) {
+          prompt.sharedWith.push(otherAgentName);
+          if (!analysis.shared.prompts.includes(prompt.name)) {
+            analysis.shared.prompts.push(prompt.name);
+          }
+        }
+      }
+      for (const tool of analysis.constituents.tools) {
+        if (otherAnalysis.tools.includes(tool.name)) {
+          tool.sharedWith.push(otherAgentName);
+          if (!analysis.shared.tools.includes(tool.name)) {
+            analysis.shared.tools.push(tool.name);
+          }
+        }
+      }
+      for (const model of analysis.constituents.models) {
+        if (otherAnalysis.models.includes(model.name)) {
+          model.sharedWith.push(otherAgentName);
+          if (!analysis.shared.models.includes(model.name)) {
+            analysis.shared.models.push(model.name);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Light analysis of an agent - just get the names of used items.
+   */
+  async analyzeAgentLight(agentName, rootDir) {
+    const result = { prompts: [], tools: [], models: [] };
+    const agentsDir = path8.join(rootDir, "agents");
+    const visited = /* @__PURE__ */ new Set();
+    const agentFilePath = this.findFile(path8.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) return result;
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    const analyzePromptLight = (promptName) => {
+      if (visited.has(promptName)) return;
+      visited.add(promptName);
+      result.prompts.push(promptName);
+      const promptFilePath = this.findFile(path8.join(agentsDir, "prompts"), promptName);
+      if (!promptFilePath) return;
+      const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+      const modelName = extractPromptModel(promptSource);
+      if (modelName && !result.models.includes(modelName)) {
+        result.models.push(modelName);
+      }
+      const { tools } = extractPromptTools(promptSource);
+      for (const tool of tools) {
+        if (!result.tools.includes(tool)) {
+          result.tools.push(tool);
+        }
+      }
+      const includes = extractPromptIncludes(promptSource);
+      for (const inc of includes) {
+        analyzePromptLight(inc);
+      }
+    };
+    if (agentPrompts.sideA) analyzePromptLight(agentPrompts.sideA);
+    if (agentPrompts.sideB) analyzePromptLight(agentPrompts.sideB);
+    return result;
+  }
+  /**
+   * Pack an agent with all its dependencies using Rollup bundling.
+   *
+   * The packing format creates:
+   * - dist/{type}/{name}.js - Individual bundled files per constituent
+   * - dist/index.js - Re-exports and lazy loaders
+   * - dist/index.d.ts - TypeScript type definitions
+   * - package.json - With standardagent field and dependencies
+   * - tsconfig.json - For building
+   *
+   * @param options - Packing options
+   * @returns Packing result
+   */
+  async pack(options) {
+    const {
+      agentName,
+      rootDir,
+      outputDir,
+      version = "1.0.0",
+      removeOriginals = false,
+      packageId = `standardagent-${agentName.replace(/_/g, "-")}`,
+      packageName,
+      license,
+      licenseOwner,
+      itemSelections,
+      readme
+    } = options;
+    const finalPackageName = packageName || packageId;
+    const packedAt = Date.now();
+    const meta = {
+      packageId,
+      version,
+      entryAgents: [agentName],
+      packedAt
+    };
+    const result = {
+      success: false,
+      packageId,
+      outputPath: "",
+      meta,
+      filesCreated: [],
+      warnings: []
+    };
+    try {
+      const analysis = await this.analyzeAgent(agentName, rootDir);
+      if (analysis.errors.length > 0) {
+        result.error = analysis.errors.join("\n");
+        result.warnings = analysis.warnings;
+        return result;
+      }
+      result.warnings = analysis.warnings;
+      const pkgOutputDir = path8.join(outputDir, packageId);
+      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs2.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      const seenItems = /* @__PURE__ */ new Set();
+      const allItems = [];
+      for (const a of analysis.constituents.agents) {
+        const key = `agent:${a.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...a, type: "agent" });
+        }
+      }
+      for (const p of analysis.constituents.prompts) {
+        const key = `prompt:${p.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...p, type: "prompt" });
+        }
+      }
+      for (const t of analysis.constituents.tools) {
+        const key = `tool:${t.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...t, type: "tool" });
+        }
+      }
+      for (const m of analysis.constituents.models) {
+        const key = `model:${m.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...m, type: "model" });
+        }
+      }
+      for (const h of analysis.constituents.hooks) {
+        const key = `hook:${h.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...h, type: "hook" });
+        }
+      }
+      const externalDeps = /* @__PURE__ */ new Map();
+      for (const item of allItems) {
+        const outputPath = path8.join(
+          pkgOutputDir,
+          "dist",
+          this.getTypeDir(item.type),
+          `${item.name}.js`
+        );
+        const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
+        for (const [depName, depVersion] of deps) {
+          if (!externalDeps.has(depName)) {
+            externalDeps.set(depName, depVersion);
+          }
+        }
+        result.filesCreated.push(outputPath);
+      }
+      const indexJs = this.generateReExportIndex(analysis, meta);
+      const indexJsPath = path8.join(pkgOutputDir, "dist", "index.js");
+      fs2.writeFileSync(indexJsPath, indexJs);
+      result.filesCreated.push(indexJsPath);
+      const indexDts = this.generateIndexDts(analysis);
+      const indexDtsPath = path8.join(pkgOutputDir, "dist", "index.d.ts");
+      fs2.writeFileSync(indexDtsPath, indexDts);
+      result.filesCreated.push(indexDtsPath);
+      const pkgJson = this.generatePackageJson(
+        finalPackageName,
+        version,
+        agentName,
+        externalDeps,
+        rootDir,
+        license,
+        licenseOwner
+      );
+      const pkgJsonPath = path8.join(pkgOutputDir, "package.json");
+      fs2.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");
+        fs2.writeFileSync(licensePath, licenseContent);
+        result.filesCreated.push(licensePath);
+      }
+      let readmeContent = readme;
+      if (!readmeContent) {
+        const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
+        let agentDescription;
+        if (agentItem?.filePath) {
+          const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+          agentDescription = extractAgentDescription(agentSource) || void 0;
+        }
+        readmeContent = this.generateReadme(
+          finalPackageName,
+          agentName,
+          version,
+          license,
+          agentDescription
+        );
+      }
+      const readmePath = path8.join(pkgOutputDir, "README.md");
+      fs2.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;
+          if (shouldRemove && fs2.existsSync(item.filePath)) {
+            fs2.unlinkSync(item.filePath);
+            result.filesRemoved.push(item.filePath);
+          }
+        }
+      }
+      const agentsDir = path8.join(rootDir, "agents");
+      const metadataService = new MetadataService(agentsDir);
+      const metadata = {
+        packageName: finalPackageName,
+        version,
+        license: license || "",
+        licenseOwner: licenseOwner || "",
+        lastPackedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await metadataService.write(agentName, metadata);
+      result.success = true;
+      result.outputPath = pkgOutputDir;
+      result.meta = meta;
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+      return result;
+    }
+  }
+  /**
+   * Bundle a single source file with its local dependencies using Rollup.
+   *
+   * Local files (from the same agents/ directory) are inlined.
+   * npm packages are kept as external dependencies.
+   * Output is bundled JavaScript with all local deps inlined.
+   *
+   * @returns Map of external dependencies (name -> version specifier)
+   */
+  async bundleFile(inputPath, outputPath, rootDir) {
+    const { rollup } = await import('rollup');
+    const nodeResolve = (await import('@rollup/plugin-node-resolve')).default;
+    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 resolveVersion = this.resolvePackageVersion.bind(this);
+    const trackExternalsPlugin = {
+      name: "track-externals",
+      resolveId(source, importer) {
+        if (!importer) {
+          return null;
+        }
+        if (source.startsWith("./") || source.startsWith("../")) {
+          const resolved = path8.resolve(path8.dirname(importer), source);
+          let tsResolved = resolved;
+          if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
+            if (fs2.existsSync(`${resolved}.ts`)) {
+              tsResolved = `${resolved}.ts`;
+            } else if (fs2.existsSync(`${resolved}.js`)) {
+              tsResolved = `${resolved}.js`;
+            } else if (fs2.existsSync(`${resolved}/index.ts`)) {
+              tsResolved = `${resolved}/index.ts`;
+            }
+          }
+          if (tsResolved.includes(agentsDir) || resolved.includes(agentsDir)) {
+            return null;
+          }
+          return null;
+        }
+        if (source.startsWith("/") && source.includes(agentsDir)) {
+          return null;
+        }
+        const pkgName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+        if (pkgName.startsWith("@standardagents/")) {
+          externalDeps.set(pkgName, resolveVersion(pkgName, rootDir));
+        } else if (pkgName === "zod") {
+          externalDeps.set(pkgName, "^4.0.0");
+        } else {
+          externalDeps.set(pkgName, "*");
+        }
+        return { id: source, external: true };
+      }
+    };
+    const rollupOptions = {
+      input: inputPath,
+      plugins: [
+        trackExternalsPlugin,
+        nodeResolve({
+          extensions: [".ts", ".js"]
+        }),
+        commonjs(),
+        esbuild({
+          target: "es2022",
+          sourceMap: false
+        })
+      ],
+      onwarn(warning, warn) {
+        if (warning.code === "UNRESOLVED_IMPORT") return;
+        if (warning.code === "CIRCULAR_DEPENDENCY") return;
+        warn(warning);
+      }
+    };
+    const bundle = await rollup(rollupOptions);
+    try {
+      const { output } = await bundle.generate({
+        format: "esm",
+        exports: "named"
+      });
+      const bundledCode = output[0].code;
+      const header = `// Bundled from: ${path8.relative(rootDir, inputPath)}
+// Local dependencies have been inlined
+
+`;
+      fs2.writeFileSync(outputPath, header + bundledCode);
+      await bundle.close();
+    } catch (error) {
+      await bundle.close();
+      throw error;
+    }
+    return externalDeps;
+  }
+  /**
+   * Get the directory name for a constituent type.
+   */
+  getTypeDir(type) {
+    switch (type) {
+      case "agent":
+        return "agents";
+      case "prompt":
+        return "prompts";
+      case "tool":
+        return "tools";
+      case "model":
+        return "models";
+      case "hook":
+        return "hooks";
+    }
+  }
+  /**
+   * Deduplicate constituents by name (for packing, not for tree display).
+   */
+  deduplicateConstituents(analysis) {
+    const dedupe = (items) => {
+      const seen = /* @__PURE__ */ new Set();
+      return items.filter((item) => {
+        if (seen.has(item.name)) return false;
+        seen.add(item.name);
+        return true;
+      });
+    };
+    return {
+      agents: dedupe(analysis.constituents.agents),
+      prompts: dedupe(analysis.constituents.prompts),
+      tools: dedupe(analysis.constituents.tools),
+      models: dedupe(analysis.constituents.models),
+      hooks: dedupe(analysis.constituents.hooks)
+    };
+  }
+  /**
+   * Check if a name is a valid JavaScript/TypeScript identifier.
+   */
+  isValidIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+  /**
+   * Quote a property/export name if it contains non-identifier characters.
+   * JavaScript identifiers must start with a letter, underscore, or dollar sign,
+   * and contain only letters, digits, underscores, or dollar signs.
+   */
+  quoteName(name) {
+    if (this.isValidIdentifier(name)) {
+      return name;
+    }
+    return `'${name}'`;
+  }
+  /**
+   * Generate the dist/index.js file with re-exports and lazy loaders.
+   */
+  generateReExportIndex(analysis, meta) {
+    const constituents = this.deduplicateConstituents(analysis);
+    const lines = [
+      "// Packed agent: " + analysis.agent,
+      "// Generated by @standardagents/builder",
+      ""
+    ];
+    for (const agent of constituents.agents) {
+      lines.push(`export { default as ${this.quoteName(agent.name)} } from './agents/${agent.name}.js';`);
+    }
+    for (const prompt of constituents.prompts) {
+      lines.push(`export { default as ${this.quoteName(prompt.name)} } from './prompts/${prompt.name}.js';`);
+    }
+    for (const tool of constituents.tools) {
+      lines.push(`export { default as ${this.quoteName(tool.name)} } from './tools/${tool.name}.js';`);
+    }
+    for (const model of constituents.models) {
+      lines.push(`export { default as ${this.quoteName(model.name)} } from './models/${model.name}.js';`);
+    }
+    for (const hook of constituents.hooks) {
+      lines.push(`export { default as ${this.quoteName(hook.name)} } from './hooks/${hook.name}.js';`);
+    }
+    lines.push("");
+    lines.push("// Registry exports for lazy loading");
+    lines.push("export const agents = {");
+    for (const agent of constituents.agents) {
+      lines.push(`  ${this.quoteName(agent.name)}: async () => (await import('./agents/${agent.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const prompts = {");
+    for (const prompt of constituents.prompts) {
+      lines.push(`  ${this.quoteName(prompt.name)}: async () => (await import('./prompts/${prompt.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const tools = {");
+    for (const tool of constituents.tools) {
+      lines.push(`  ${this.quoteName(tool.name)}: async () => (await import('./tools/${tool.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const models = {");
+    for (const model of constituents.models) {
+      lines.push(`  ${this.quoteName(model.name)}: async () => (await import('./models/${model.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const hooks = {");
+    for (const hook of constituents.hooks) {
+      lines.push(`  ${this.quoteName(hook.name)}: async () => (await import('./hooks/${hook.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const __meta = " + JSON.stringify(meta, null, 2) + ";");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate the dist/index.d.ts file with type definitions.
+   */
+  generateIndexDts(analysis) {
+    const constituents = this.deduplicateConstituents(analysis);
+    const lines = [
+      "import type {",
+      "  AgentDefinition,",
+      "  PromptDefinition,",
+      "  ToolDefinition,",
+      "  ModelDefinition,",
+      "  PackedMeta,",
+      "} from '@standardagents/spec';",
+      "",
+      "type DefinitionLoader<T> = () => Promise<T>;",
+      ""
+    ];
+    for (const agent of constituents.agents) {
+      if (this.isValidIdentifier(agent.name)) {
+        lines.push(`export declare const ${agent.name}: AgentDefinition;`);
+      }
+    }
+    for (const prompt of constituents.prompts) {
+      if (this.isValidIdentifier(prompt.name)) {
+        lines.push(`export declare const ${prompt.name}: PromptDefinition;`);
+      }
+    }
+    for (const tool of constituents.tools) {
+      if (this.isValidIdentifier(tool.name)) {
+        lines.push(`export declare const ${tool.name}: ToolDefinition<unknown, any, any>;`);
+      }
+    }
+    for (const model of constituents.models) {
+      if (this.isValidIdentifier(model.name)) {
+        lines.push(`export declare const ${model.name}: ModelDefinition;`);
+      }
+    }
+    for (const hook of constituents.hooks) {
+      if (this.isValidIdentifier(hook.name)) {
+        lines.push(`export declare const ${hook.name}: unknown;`);
+      }
+    }
+    lines.push("");
+    lines.push("export declare const agents: {");
+    for (const agent of constituents.agents) {
+      lines.push(`  readonly ${this.quoteName(agent.name)}: DefinitionLoader<AgentDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const prompts: {");
+    for (const prompt of constituents.prompts) {
+      lines.push(`  readonly ${this.quoteName(prompt.name)}: DefinitionLoader<PromptDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const tools: {");
+    for (const tool of constituents.tools) {
+      lines.push(`  readonly ${this.quoteName(tool.name)}: DefinitionLoader<ToolDefinition<unknown, any, any>>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const models: {");
+    for (const model of constituents.models) {
+      lines.push(`  readonly ${this.quoteName(model.name)}: DefinitionLoader<ModelDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const hooks: {");
+    for (const hook of constituents.hooks) {
+      lines.push(`  readonly ${this.quoteName(hook.name)}: DefinitionLoader<unknown>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const __meta: PackedMeta;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate the package.json file with dependencies.
+   */
+  generatePackageJson(packageName, version, agentName, externalDeps, rootDir, license, licenseOwner) {
+    const dependencies = {
+      "@standardagents/spec": this.resolvePackageVersion("@standardagents/spec", rootDir)
+    };
+    for (const [name, ver] of externalDeps) {
+      dependencies[name] = ver;
+    }
+    const pkgJson = {
+      name: packageName,
+      version,
+      type: "module",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        }
+      },
+      keywords: ["standardagent"],
+      standardagent: {
+        entryAgents: [agentName]
+      },
+      files: license ? ["dist", "LICENSE", "README.md"] : ["dist", "README.md"],
+      dependencies
+    };
+    if (license) {
+      pkgJson.license = license;
+    }
+    if (licenseOwner) {
+      pkgJson.author = licenseOwner;
+    }
+    return pkgJson;
+  }
+  /**
+   * Generate LICENSE file content for common licenses.
+   */
+  generateLicenseFile(license, owner) {
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const copyrightHolder = owner || "[COPYRIGHT HOLDER]";
+    switch (license) {
+      case "MIT":
+        return `MIT License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+      case "Apache-2.0":
+        return `                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   Copyright ${year} ${copyrightHolder}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+`;
+      case "ISC":
+        return `ISC License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+`;
+      case "GPL-3.0":
+        return `GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (c) ${year} ${copyrightHolder}
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+`;
+      case "BSD-3-Clause":
+        return `BSD 3-Clause License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+`;
+      case "Unlicensed":
+      case "UNLICENSED":
+        return `Copyright (c) ${year} ${copyrightHolder}
+
+All Rights Reserved.
+
+This software and associated documentation files (the "Software") are
+proprietary and confidential. Unauthorized copying, modification, distribution,
+or use of the Software, via any medium, is strictly prohibited.
+`;
+      default:
+        return `${license}
+
+Copyright (c) ${year} ${copyrightHolder}
+`;
+    }
+  }
+  /**
+   * Get information about a packed package.
+   *
+   * Reads the package.json and README.md from a packed package directory.
+   * Used by the packed-info API endpoint to show package details before publishing.
+   *
+   * @param packageId - The package directory name (e.g., 'standardagent-my-agent')
+   * @param rootDir - Root directory of the project
+   * @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 (!fs2.existsSync(packageDir)) {
+      if (!fs2.existsSync(packedDir)) {
+        return null;
+      }
+      const dirs = fs2.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);
+    }
+    const pkgJsonPath = path8.join(packageDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    let readme;
+    const readmePath = path8.join(packageDir, "README.md");
+    if (fs2.existsSync(readmePath)) {
+      readme = fs2.readFileSync(readmePath, "utf-8");
+    }
+    return {
+      packageName: pkgJson.name,
+      version: pkgJson.version,
+      license: pkgJson.license,
+      author: pkgJson.author,
+      entryAgents: pkgJson.standardagent?.entryAgents || [],
+      readme
+    };
+  }
+  /**
+   * List all packed packages in the workspace.
+   *
+   * @param rootDir - Root directory of the project
+   * @returns Array of package directory names
+   */
+  listPackedPackages(rootDir) {
+    const packedDir = path8.join(rootDir, "agents", "packed");
+    if (!fs2.existsSync(packedDir)) {
+      return [];
+    }
+    return fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  }
+  /**
+   * Generate README.md content for a packed agent.
+   *
+   * @param packageName - The npm package name
+   * @param agentName - The agent name
+   * @param version - The package version
+   * @param license - The license type
+   * @param description - Optional description from the agent definition
+   * @returns README markdown content
+   */
+  generateReadme(packageName, agentName, version, license, description) {
+    const desc = description || "A Standard Agent package.";
+    return `# ${packageName}
+
+${desc}
+
+## Installation
+
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
+
+## Usage
+
+This is a [Standard Agent](https://standardagentbuilder.com) package. To use it:
+
+1. Install in your Standard Agents project
+2. The agent will be automatically discovered and available
+
+\`\`\`typescript
+// Create a thread with this agent
+const thread = await client.createThread({
+  agent_id: '${packageName}/${agentName}'
+});
+\`\`\`
+
+## License
+
+${license || "See LICENSE file"}
+`;
+  }
+  /**
+   * Find a file by name in a directory.
+   */
+  findFile(dir, name) {
+    if (!fs2.existsSync(dir)) {
+      return null;
+    }
+    const exactPath = path8.join(dir, `${name}.ts`);
+    if (fs2.existsSync(exactPath)) {
+      return exactPath;
+    }
+    const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    for (const file of files) {
+      const filePath = path8.join(dir, file);
+      const source = fs2.readFileSync(filePath, "utf-8");
+      const extractedName = extractDefinitionName(source);
+      if (extractedName === name) {
+        return filePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * List all agents in the workspace.
+   */
+  listAgents(rootDir) {
+    const agentsDir = path8.join(rootDir, "agents", "agents");
+    if (!fs2.existsSync(agentsDir)) {
+      return [];
+    }
+    const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const agents = [];
+    for (const file of files) {
+      const filePath = path8.join(agentsDir, file);
+      const source = fs2.readFileSync(filePath, "utf-8");
+      const name = extractDefinitionName(source);
+      if (name) {
+        agents.push(name);
+      } else {
+        agents.push(file.replace(".ts", ""));
+      }
+    }
+    return agents;
+  }
+};
+var PackageDiscoveryService = class {
+  config;
+  constructor(config) {
+    this.config = {
+      rootDir: config.rootDir,
+      packedDir: config.packedDir ?? path8.join(config.rootDir, "agents", "packed"),
+      scanNpm: config.scanNpm ?? true,
+      scanLocal: config.scanLocal ?? true
+    };
+  }
+  /**
+   * Discover all packed agent packages.
+   *
+   * @returns Array of discovered packages
+   */
+  async discoverPackages() {
+    const packages = [];
+    if (this.config.scanNpm) {
+      const npmPackages = await this.discoverNpmPackages();
+      packages.push(...npmPackages);
+    }
+    if (this.config.scanLocal) {
+      const localPackages = await this.discoverLocalPackages();
+      packages.push(...localPackages);
+    }
+    return packages;
+  }
+  /**
+   * Discover npm packages that are Standard Agents packages.
+   *
+   * Looks for packages with:
+   * - "standardagent" keyword in package.json
+   * - "standardagent-*" prefix in name
+   * - "@standardagents/*" scope
+   * - "standardagent" field in package.json
+   */
+  async discoverNpmPackages() {
+    const packages = [];
+    const nodeModulesDir = path8.join(this.config.rootDir, "node_modules");
+    if (!fs2.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 scopeEntries = await this.scanDirectory(scopeDir);
+        for (const scopedPkg of scopeEntries) {
+          if (scopedPkg.startsWith(".")) continue;
+          const pkgDir = path8.join(scopeDir, scopedPkg);
+          const fullName = `${entry}/${scopedPkg}`;
+          const pkg = await this.checkNpmPackage(pkgDir, fullName);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+      } else {
+        const pkgDir = path8.join(nodeModulesDir, entry);
+        const pkg = await this.checkNpmPackage(pkgDir, entry);
+        if (pkg) {
+          packages.push(pkg);
+        }
+      }
+    }
+    return packages;
+  }
+  /**
+   * Check if an npm package is a Standard Agent package.
+   *
+   * Detection is based on the `standardagent` field in package.json,
+   * which must contain `entryAgents` array.
+   */
+  async checkNpmPackage(pkgDir, pkgName) {
+    const pkgJsonPath = path8.join(pkgDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const isStandardAgent = (
+        // Has "standardagent" keyword
+        pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
+        pkgName.startsWith("standardagent-") || // Has "@standardagents/*" scope
+        pkgName.startsWith("@standardagents/") || // Has "standardagent" field
+        pkgJson.standardagent !== void 0
+      );
+      if (!isStandardAgent) {
+        return null;
+      }
+      if (!pkgJson.standardagent?.entryAgents) {
+        return null;
+      }
+      return {
+        packageId: pkgJson.name || pkgName,
+        version: pkgJson.version || "0.0.0",
+        source: "npm",
+        path: pkgDir,
+        entryAgents: pkgJson.standardagent.entryAgents,
+        description: pkgJson.description
+      };
+    } catch (error) {
+      console.warn(`[PackageDiscovery] Error reading npm package ${pkgName}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Discover local packed agents from agents/packed/ directory.
+   * Handles both regular packages and scoped packages (@scope/name).
+   */
+  async discoverLocalPackages() {
+    const packages = [];
+    if (!fs2.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 = fs2.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 = fs2.statSync(scopedPkgDir);
+          if (!scopedStat.isDirectory()) continue;
+          const fullName = `${entry}/${scopedPkg}`;
+          const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+      } else {
+        const pkg = await this.checkLocalPackage(pkgDir, entry);
+        if (pkg) {
+          packages.push(pkg);
+        }
+      }
+    }
+    return packages;
+  }
+  /**
+   * Check if a local directory is a packed agent package.
+   *
+   * Detection is based on the `standardagent` field in package.json.
+   */
+  async checkLocalPackage(pkgDir, dirName) {
+    const pkgJsonPath = path8.join(pkgDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      if (!pkgJson.standardagent?.entryAgents) {
+        return null;
+      }
+      return {
+        packageId: pkgJson.name || dirName,
+        version: pkgJson.version || "0.0.0",
+        source: "local",
+        path: pkgDir,
+        entryAgents: pkgJson.standardagent.entryAgents,
+        description: pkgJson.description
+      };
+    } catch (error) {
+      console.warn(`[PackageDiscovery] Error reading local package ${dirName}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Scan a directory and return entry names.
+   */
+  async scanDirectory(dir) {
+    if (!fs2.existsSync(dir)) {
+      return [];
+    }
+    const entries = fs2.readdirSync(dir);
+    return entries;
+  }
+  /**
+   * Validate a standardagent field structure in package.json.
+   */
+  static validateStandardAgentField(field) {
+    if (typeof field !== "object" || field === null) {
+      return false;
+    }
+    const f = field;
+    return Array.isArray(f.entryAgents) && f.entryAgents.length > 0 && f.entryAgents.every((e) => typeof e === "string");
+  }
+  /**
+   * Get a package by ID.
+   */
+  async getPackage(packageId) {
+    const packages = await this.discoverPackages();
+    return packages.find((p) => p.packageId === packageId) ?? null;
+  }
+  /**
+   * Create a package signature from a discovered package.
+   *
+   * Note: packedAt is set to current time since it's no longer
+   * stored in a manifest file.
+   */
+  static createSignature(pkg) {
+    return {
+      packageId: pkg.packageId,
+      version: pkg.version,
+      source: pkg.source,
+      packedAt: Date.now()
+    };
+  }
+};
+
+// src/packing/unpacking-service.ts
+var TYPE_TO_DIR = {
+  agent: "agents",
+  prompt: "prompts",
+  tool: "tools",
+  model: "models",
+  hook: "hooks"
+};
+var UnpackingService = class {
+  /**
+   * Analyze a package to discover what can be unpacked.
+   *
+   * @param packageId - Package ID to analyze
+   * @param rootDir - Root directory of the agents workspace
+   * @returns Analysis result with items that can be unpacked
+   */
+  async analyzeUnpack(packageId, rootDir) {
+    const analysis = {
+      packageId,
+      version: "",
+      source: "local",
+      canUnpack: false,
+      items: [],
+      warnings: [],
+      errors: []
+    };
+    try {
+      const pkg = await this.resolvePackage(packageId, rootDir);
+      if (!pkg) {
+        analysis.errors.push(`Package not found: ${packageId}`);
+        return analysis;
+      }
+      analysis.version = pkg.version;
+      analysis.source = pkg.source;
+      const indexPath = path8.join(pkg.path, "dist", "index.js");
+      if (!fs2.existsSync(indexPath)) {
+        analysis.errors.push(`Package index not found: ${indexPath}`);
+        return analysis;
+      }
+      const indexContent = fs2.readFileSync(indexPath, "utf-8");
+      const registryItems = 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 itemsWithRelations = [];
+      for (const item of registryItems) {
+        const targetPath = path8.join(agentsDir, TYPE_TO_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const existsGlobally = this.fileExists(targetPath);
+        const sourceExists = fs2.existsSync(sourcePath);
+        if (!sourceExists) {
+          analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
+          continue;
+        }
+        const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+        const children = this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
+        itemsWithRelations.push({
+          name: item.name,
+          type: item.type,
+          targetPath,
+          existsGlobally,
+          action: existsGlobally ? "skip" : "generate"
+        });
+        for (const child of children) {
+          const childTargetPath = path8.join(agentsDir, TYPE_TO_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childExists = this.fileExists(childTargetPath);
+          const childSourceExists = fs2.existsSync(childSourcePath);
+          if (!childSourceExists) {
+            continue;
+          }
+          itemsWithRelations.push({
+            name: child.name,
+            type: child.type,
+            targetPath: childTargetPath,
+            existsGlobally: childExists,
+            action: childExists ? "skip" : "generate",
+            parentKey: `${item.type}:${item.name}`
+          });
+        }
+      }
+      analysis.items = itemsWithRelations;
+      const itemsToGenerate = analysis.items.filter((i) => i.action === "generate");
+      if (itemsToGenerate.length === 0 && analysis.items.length > 0) {
+        analysis.warnings.push("All items already exist in the global namespace. Nothing to unpack.");
+      }
+      analysis.canUnpack = itemsToGenerate.length > 0;
+    } catch (error) {
+      analysis.errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return analysis;
+  }
+  /**
+   * Discover relationships from a bundled file.
+   * Returns child items that this item references.
+   */
+  discoverRelationships(type, name, bundledCode, availableItems) {
+    const children = [];
+    if (type === "agent") {
+      const prompts = extractAgentPrompts(bundledCode);
+      if (prompts.sideA && availableItems.has(`prompt:${prompts.sideA}`)) {
+        children.push({ type: "prompt", name: prompts.sideA });
+      }
+      if (prompts.sideB && availableItems.has(`prompt:${prompts.sideB}`)) {
+        children.push({ type: "prompt", name: prompts.sideB });
+      }
+    } else if (type === "prompt") {
+      const toolsResult = extractPromptTools(bundledCode);
+      for (const toolName of toolsResult.tools) {
+        if (availableItems.has(`tool:${toolName}`)) {
+          children.push({ type: "tool", name: toolName });
+        } else if (availableItems.has(`agent:${toolName}`)) {
+          children.push({ type: "agent", name: toolName });
+        }
+      }
+      const model = extractPromptModel(bundledCode);
+      if (model && availableItems.has(`model:${model}`)) {
+        children.push({ type: "model", name: model });
+      }
+    } else if (type === "tool") {
+      const usesResult = extractToolUses(bundledCode);
+      for (const useName of usesResult.uses) {
+        const colonIndex = useName.indexOf(":");
+        if (colonIndex > 0) {
+          const agentName = useName.substring(0, colonIndex);
+          if (availableItems.has(`agent:${agentName}`)) {
+            children.push({ type: "agent", name: agentName });
+          }
+        } else {
+          if (availableItems.has(`tool:${useName}`)) {
+            children.push({ type: "tool", name: useName });
+          } else if (availableItems.has(`prompt:${useName}`)) {
+            children.push({ type: "prompt", name: useName });
+          } else if (availableItems.has(`agent:${useName}`)) {
+            children.push({ type: "agent", name: useName });
+          }
+        }
+      }
+    }
+    return children;
+  }
+  /**
+   * Unpack a packed agent package by transforming bundled JS back to TypeScript.
+   *
+   * @param options - Unpacking options
+   * @returns Result of the unpacking operation
+   */
+  async unpack(options) {
+    const { packageId, rootDir, deletePackage = false, itemSelections } = options;
+    const result = {
+      success: false,
+      packageId,
+      filesGenerated: [],
+      filesSkipped: [],
+      packageDeleted: false,
+      warnings: []
+    };
+    try {
+      const analysis = await this.analyzeUnpack(packageId, rootDir);
+      if (analysis.errors.length > 0) {
+        result.error = analysis.errors.join("\n");
+        return result;
+      }
+      result.warnings.push(...analysis.warnings);
+      const pkg = await this.resolvePackage(packageId, rootDir);
+      if (!pkg) {
+        result.error = `Package not found: ${packageId}`;
+        return result;
+      }
+      const itemsToProcess = this.applySelections(analysis.items, itemSelections);
+      const pkgJsonPath = path8.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      let author = "";
+      if (typeof pkgJson.author === "string") {
+        author = pkgJson.author;
+      } else if (pkgJson.author?.name) {
+        author = pkgJson.author.name;
+      }
+      const agentMetadata = {
+        packageName: pkgJson.name || void 0,
+        version: pkgJson.version || void 0,
+        author: author || void 0,
+        license: pkgJson.license || void 0
+      };
+      const processedItems = /* @__PURE__ */ new Set();
+      for (const item of itemsToProcess) {
+        const itemKey = `${item.type}:${item.name}`;
+        if (processedItems.has(itemKey)) {
+          continue;
+        }
+        processedItems.add(itemKey);
+        if (item.action === "skip") {
+          result.filesSkipped.push(item.targetPath);
+          continue;
+        }
+        try {
+          const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+          let tsCode = transformBundledJs(bundledCode);
+          if (item.type === "agent") {
+            tsCode = injectAgentMetadata(tsCode, agentMetadata);
+          }
+          const dir = path8.dirname(item.targetPath);
+          if (!fs2.existsSync(dir)) {
+            fs2.mkdirSync(dir, { recursive: true });
+          }
+          fs2.writeFileSync(item.targetPath, tsCode);
+          result.filesGenerated.push(item.targetPath);
+        } catch (error) {
+          result.warnings.push(
+            `Failed to generate ${item.type} "${item.name}": ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (deletePackage && pkg.source === "local") {
+        try {
+          this.deleteDirectory(pkg.path);
+          result.packageDeleted = true;
+        } catch (error) {
+          result.warnings.push(
+            `Failed to delete package: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      } else if (deletePackage && pkg.source === "npm") {
+        result.warnings.push("Cannot delete npm packages. Use npm uninstall instead.");
+      }
+      result.success = true;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+    }
+    return result;
+  }
+  /**
+   * Parse the index.js file to extract registry items.
+   *
+   * Looks for patterns like:
+   * ```javascript
+   * export const agents = {
+   *   support_agent: async () => (await import('./agents/support_agent.js')).default,
+   * };
+   * ```
+   */
+  parseIndexExports(indexContent) {
+    const sourceFile = ts.createSourceFile(
+      "index.js",
+      indexContent,
+      ts.ScriptTarget.ESNext,
+      true
+    );
+    const items = [];
+    const registryTypes = ["agent", "prompt", "tool", "model", "hook"];
+    function visit(node) {
+      if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+        for (const decl of node.declarationList.declarations) {
+          if (!ts.isIdentifier(decl.name)) continue;
+          const varName = decl.name.text;
+          let itemType = null;
+          for (const type of registryTypes) {
+            if (varName === TYPE_TO_DIR[type]) {
+              itemType = type;
+              break;
+            }
+          }
+          if (itemType && decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
+            for (const prop of decl.initializer.properties) {
+              if (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) {
+                let name;
+                if (ts.isPropertyAssignment(prop)) {
+                  if (ts.isIdentifier(prop.name)) {
+                    name = prop.name.text;
+                  } else if (ts.isStringLiteral(prop.name)) {
+                    name = prop.name.text;
+                  }
+                } else if (ts.isShorthandPropertyAssignment(prop)) {
+                  name = prop.name.text;
+                }
+                if (name) {
+                  items.push({ name, type: itemType });
+                }
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return items;
+  }
+  /**
+   * Resolve a package identifier to a discovered package.
+   */
+  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 (fs2.existsSync(pkgJsonPath2)) {
+        try {
+          const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath2, "utf-8"));
+          if (pkgJson.standardagent?.entryAgents) {
+            return {
+              packageId: pkgJson.name || path8.basename(absolutePath),
+              version: pkgJson.version || "0.0.0",
+              source: "local",
+              path: absolutePath,
+              entryAgents: pkgJson.standardagent.entryAgents
+            };
+          }
+        } catch {
+        }
+      }
+      return null;
+    }
+    const packedDir = path8.join(rootDir, "agents", "packed", pkgIdentifier);
+    const pkgJsonPath = path8.join(packedDir, "package.json");
+    if (fs2.existsSync(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkgJson.standardagent?.entryAgents) {
+          return {
+            packageId: pkgJson.name || pkgIdentifier,
+            version: pkgJson.version || "0.0.0",
+            source: "local",
+            path: packedDir,
+            entryAgents: pkgJson.standardagent.entryAgents
+          };
+        }
+      } catch {
+      }
+    }
+    const discovery = new PackageDiscoveryService({ rootDir });
+    const packages = await discovery.discoverPackages();
+    const pkg = packages.find(
+      (p) => p.packageId === pkgIdentifier || p.path.endsWith(`node_modules/${pkgIdentifier}`)
+    );
+    return pkg || null;
+  }
+  /**
+   * Apply user selections to items.
+   */
+  applySelections(items, selections) {
+    if (!selections || selections.length === 0) {
+      return items;
+    }
+    return items.map((item) => {
+      const selection = selections.find(
+        (s) => s.name === item.name && s.type === item.type
+      );
+      if (selection) {
+        return { ...item, action: selection.action };
+      }
+      return item;
+    });
+  }
+  /**
+   * Check if a file exists.
+   */
+  fileExists(filePath) {
+    if (fs2.existsSync(filePath)) {
+      return true;
+    }
+    const withoutExt = filePath.replace(/\.(ts|js)$/, "");
+    return fs2.existsSync(`${withoutExt}.ts`) || fs2.existsSync(`${withoutExt}.js`);
+  }
+  /**
+   * Recursively delete a directory.
+   */
+  deleteDirectory(dirPath) {
+    if (fs2.existsSync(dirPath)) {
+      fs2.rmSync(dirPath, { recursive: true, force: true });
+    }
+  }
+  /**
+   * List available packed packages.
+   */
+  async listPackages(rootDir) {
+    const discovery = new PackageDiscoveryService({ rootDir });
+    const packages = await discovery.discoverPackages();
+    return packages.map((pkg) => ({
+      packageId: pkg.packageId,
+      version: pkg.version,
+      source: pkg.source,
+      entryAgents: pkg.entryAgents,
+      path: pkg.path
+    }));
+  }
+};
+var execAsync = promisify(exec);
+var NpmPublishService = class {
+  /**
+   * Validate an npm auth token format.
+   *
+   * @param token - Token to validate
+   * @returns true if token appears valid
+   */
+  validateToken(token) {
+    if (!token || token.trim().length === 0) {
+      return false;
+    }
+    return token.trim().length >= 10;
+  }
+  /**
+   * Validate a registry URL.
+   *
+   * @param registry - Registry URL to validate
+   * @returns true if URL is valid https URL
+   */
+  validateRegistry(registry) {
+    try {
+      const url = new URL(registry);
+      return url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Publish a package to npm.
+   *
+   * Creates a temporary .npmrc with the token, runs npm publish,
+   * and deletes the .npmrc immediately after.
+   *
+   * @param options - Publish options
+   * @returns Publish result
+   */
+  async publish(options) {
+    const {
+      packageDir,
+      token,
+      registry = "https://registry.npmjs.org",
+      dryRun = false
+    } = options;
+    if (!this.validateToken(token)) {
+      return {
+        success: false,
+        output: "",
+        error: "Invalid npm token format"
+      };
+    }
+    if (!this.validateRegistry(registry)) {
+      return {
+        success: false,
+        output: "",
+        error: "Registry URL must use HTTPS"
+      };
+    }
+    const pkgJsonPath = path8.join(packageDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return {
+        success: false,
+        output: "",
+        error: "package.json not found in package directory"
+      };
+    }
+    let packageName;
+    let version;
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      packageName = pkgJson.name;
+      version = pkgJson.version;
+    } catch (e) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to read package.json: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+    const npmrcPath = path8.join(packageDir, ".npmrc");
+    const registryHost = new URL(registry).host;
+    const npmrcContent = `//${registryHost}/:_authToken=${token}
+registry=${registry}
+`;
+    try {
+      fs2.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
+      const args = ["publish"];
+      if (dryRun) {
+        args.push("--dry-run");
+      }
+      args.push("--access", "public");
+      const command = `npm ${args.join(" ")}`;
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: packageDir,
+        env: {
+          ...process.env,
+          // Ensure npm uses our .npmrc
+          npm_config_userconfig: npmrcPath
+        }
+      });
+      const output = [stdout, stderr].filter(Boolean).join("\n");
+      return {
+        success: true,
+        output,
+        packageName,
+        version
+      };
+    } catch (e) {
+      const error = e;
+      const output = [error.stdout, error.stderr].filter(Boolean).join("\n");
+      return {
+        success: false,
+        output,
+        error: error.message || "npm publish failed"
+      };
+    } finally {
+      try {
+        if (fs2.existsSync(npmrcPath)) {
+          fs2.unlinkSync(npmrcPath);
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check if a package version already exists on the registry.
+   *
+   * @param packageName - Package name
+   * @param version - Version to check
+   * @param registry - Registry URL
+   * @returns true if version exists
+   */
+  async versionExists(packageName, version, registry = "https://registry.npmjs.org") {
+    try {
+      const url = `${registry}/${packageName}/${version}`;
+      const response = await fetch(url);
+      return response.status === 200;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the npm package URL for a published package.
+   *
+   * @param packageName - Package name
+   * @param registry - Registry URL
+   * @returns URL to view the package
+   */
+  getPackageUrl(packageName, registry = "https://registry.npmjs.org") {
+    if (registry === "https://registry.npmjs.org") {
+      return `https://www.npmjs.com/package/${packageName}`;
+    }
+    return `${registry}/${packageName}`;
+  }
+};
+
+// src/plugin.ts
+var VIRTUAL_TOOLS_ID = "virtual:@standardagents-tools";
+var RESOLVED_VIRTUAL_TOOLS_ID = "\0" + VIRTUAL_TOOLS_ID;
+var VIRTUAL_ROUTES_ID = "virtual:@standardagents-routes";
+var RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
+var VIRTUAL_ROUTER_ID = "virtual:@standardagents/router";
+var RESOLVED_VIRTUAL_ROUTER_ID = "\0" + VIRTUAL_ROUTER_ID;
+var VIRTUAL_HOOKS_ID = "virtual:@standardagents-hooks";
+var RESOLVED_VIRTUAL_HOOKS_ID = "\0" + VIRTUAL_HOOKS_ID;
+var VIRTUAL_CONFIG_ID = "virtual:@standardagents-config";
+var RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+var VIRTUAL_THREAD_API_ID = "virtual:@standardagents-thread-api";
+var RESOLVED_VIRTUAL_THREAD_API_ID = "\0" + VIRTUAL_THREAD_API_ID;
+var VIRTUAL_MODELS_ID = "virtual:@standardagents-models";
+var RESOLVED_VIRTUAL_MODELS_ID = "\0" + VIRTUAL_MODELS_ID;
+var VIRTUAL_PROMPTS_ID = "virtual:@standardagents-prompts";
+var RESOLVED_VIRTUAL_PROMPTS_ID = "\0" + VIRTUAL_PROMPTS_ID;
+var VIRTUAL_AGENTS_ID = "virtual:@standardagents-agents";
+var RESOLVED_VIRTUAL_AGENTS_ID = "\0" + VIRTUAL_AGENTS_ID;
+var VIRTUAL_EFFECTS_ID = "virtual:@standardagents-effects";
+var RESOLVED_VIRTUAL_EFFECTS_ID = "\0" + VIRTUAL_EFFECTS_ID;
+var VIRTUAL_PROVIDERS_ID = "virtual:@standardagents-providers";
+var RESOLVED_VIRTUAL_PROVIDERS_ID = "\0" + VIRTUAL_PROVIDERS_ID;
+var VIRTUAL_REGISTRY_ID = "virtual:@standardagents-registry";
+var RESOLVED_VIRTUAL_REGISTRY_ID = "\0" + VIRTUAL_REGISTRY_ID;
+var VIRTUAL_BUILDER_ID = "virtual:@standardagents/builder";
+var RESOLVED_VIRTUAL_BUILDER_ID = "\0" + VIRTUAL_BUILDER_ID;
+function scanApiDirectory(dir, baseRoute = "") {
+  const routes = [];
+  if (!fs2__default.existsSync(dir)) {
+    return routes;
+  }
+  try {
+    const entries = fs2__default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8__default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const convertedDirName = entry.name.replace(/\[([^\]]+)\]/g, ":$1");
+        const subRoute = baseRoute + "/" + convertedDirName;
+        routes.push(...scanApiDirectory(fullPath, subRoute));
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        const fileName = entry.name.replace(/\.ts$/, "");
+        let method = "";
+        let routePath = baseRoute;
+        if (fileName.includes(".")) {
+          const parts = fileName.split(".");
+          const methodPart = parts[parts.length - 1].toUpperCase();
+          if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(methodPart)) {
+            method = methodPart;
+            const pathPart = parts.slice(0, -1).join(".");
+            if (pathPart !== "index") {
+              const convertedPath = pathPart.replace(/\[([^\]]+)\]/g, ":$1");
+              routePath += "/" + convertedPath;
+            }
+          } else {
+            if (fileName !== "index") {
+              const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
+              routePath += "/" + convertedPath;
+            }
+          }
+        } else {
+          if (fileName !== "index") {
+            const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
+            routePath += "/" + convertedPath;
+          }
+        }
+        const importPath = "./" + path8__default.relative(process.cwd(), fullPath).replace(/\\/g, "/");
+        routes.push({
+          method,
+          route: routePath || "/",
+          importPath
+        });
+      }
+    }
+    return routes;
+  } catch (error) {
+    console.error(`Error scanning API directory ${dir}:`, error);
+    return [];
+  }
+}
+function isSnakeCase(str) {
+  return /^[a-z][a-z0-9_]*[a-z0-9]$/.test(str) || /^[a-z]$/.test(str);
+}
+function validateToolFile(filePath, fileName) {
+  try {
+    const content = fs2__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()`;
+    }
+    return null;
+  } catch (error) {
+    return `Failed to read tool file '${fileName}.ts'`;
+  }
+}
+async function scanToolsDirectory(dir) {
+  const tools = [];
+  if (!fs2__default.existsSync(dir)) {
+    return tools;
+  }
+  const entries = await fs2__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, "/");
+      let toolError;
+      const validationError = validateToolFile(filePath, fileName);
+      if (validationError) {
+        toolError = validationError;
+        console.error(`
+\u274C Tool validation error: ${validationError}`);
+      }
+      if (!isSnakeCase(fileName)) {
+        const warning = `Tool name should be in snake_case format (e.g., 'log_name', 'send_email')`;
+        if (toolError) {
+          toolError += ` | ${warning}`;
+        } else {
+          toolError = warning;
+        }
+        console.warn(
+          `
+\u26A0\uFE0F  Tool naming warning: '${fileName}' should be in snake_case format (e.g., 'log_name', 'send_email')`
+        );
+      }
+      tools.push({ name: fileName, importPath, error: toolError });
+    }
+  }
+  return tools;
+}
+async function scanHooksDirectory(dir) {
+  const hooks = [];
+  if (!fs2__default.existsSync(dir)) {
+    return hooks;
+  }
+  const entries = await fs2__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, "/");
+      try {
+        const content = fs2__default.readFileSync(filePath, "utf-8");
+        const idMatch = content.match(/id:\s*['"]([^'"]+)['"]/);
+        const hookMatch = content.match(/hook:\s*['"]([^'"]+)['"]/);
+        if (idMatch && hookMatch) {
+          hooks.push({
+            id: idMatch[1],
+            hook: hookMatch[1],
+            importPath
+          });
+        } else {
+          console.warn(
+            `[vite-plugin-agent] Hook file '${entry.name}' is using deprecated format. Please update to use defineHook({ hook: '...', id: '...', execute: ... })`
+          );
+        }
+      } catch (error) {
+        console.error(`[vite-plugin-agent] Error reading hook file ${entry.name}:`, error);
+      }
+    }
+  }
+  return hooks;
+}
+async function scanConfigDirectory(dir, definePattern) {
+  const items = [];
+  if (!fs2__default.existsSync(dir)) {
+    return items;
+  }
+  const entries = await fs2__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, "/");
       try {
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const content = fs2__default.readFileSync(filePath, "utf-8");
         const hasDefaultExport = definePattern.test(content);
         if (!hasDefaultExport) {
           items.push({
@@ -2054,20 +4431,20 @@ async function scanAgentsDirectory(dir) {
 }
 async function scanEffectsDirectory(dir) {
   const effects = [];
-  if (!fs2.existsSync(dir)) {
+  if (!fs2__default.existsSync(dir)) {
     return effects;
   }
-  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs2__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 = path3.join(dir, entry.name);
-      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path8__default.join(dir, entry.name);
+      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       if (fileName === "CLAUDE" || fileName.startsWith("_")) {
         continue;
       }
       try {
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const content = fs2__default.readFileSync(filePath, "utf-8");
         if (!content.includes("defineEffect")) {
           continue;
         }
@@ -2080,14 +4457,14 @@ async function scanEffectsDirectory(dir) {
   return effects;
 }
 function parseRequestBody(req) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
     req.on("end", () => {
       try {
-        resolve(body ? JSON.parse(body) : {});
+        resolve2(body ? JSON.parse(body) : {});
       } catch (e) {
         reject(new Error("Invalid JSON body"));
       }
@@ -2103,19 +4480,20 @@ function agentbuilder(options = {}) {
   if (mountPoint.endsWith("/") && mountPoint.length > 1) {
     mountPoint = mountPoint.slice(0, -1);
   }
-  const toolsDir = options.toolsDir ? path3.resolve(process.cwd(), options.toolsDir) : path3.resolve(process.cwd(), "agents/tools");
-  const hooksDir = options.hooksDir ? path3.resolve(process.cwd(), options.hooksDir) : path3.resolve(process.cwd(), "agents/hooks");
-  const threadApiDir = options.apiDir ? path3.resolve(process.cwd(), options.apiDir) : path3.resolve(process.cwd(), "agents/api");
-  const modelsDir = options.modelsDir ? path3.resolve(process.cwd(), options.modelsDir) : path3.resolve(process.cwd(), "agents/models");
-  const promptsDir = options.promptsDir ? path3.resolve(process.cwd(), options.promptsDir) : path3.resolve(process.cwd(), "agents/prompts");
-  const agentsDir = options.agentsDir ? path3.resolve(process.cwd(), options.agentsDir) : path3.resolve(process.cwd(), "agents/agents");
-  const effectsDir = options.effectsDir ? path3.resolve(process.cwd(), options.effectsDir) : path3.resolve(process.cwd(), "agents/effects");
-  const outputDir = path3.resolve(process.cwd(), ".agents");
+  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 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 outputDir = path8__default.resolve(process.cwd(), ".agents");
   const typeGenConfig = {
     modelsDir,
     promptsDir,
     agentsDir,
     toolsDir,
+    hooksDir,
     outputDir
   };
   function regenerateTypes() {
@@ -2124,15 +4502,17 @@ function agentbuilder(options = {}) {
     }
   }
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path3.dirname(__filename);
-  const rou3Path = path3.join(__dirname, "../dist/rou3.js");
+  const __dirname = path8__default.dirname(__filename);
+  const rou3Path = path8__default.join(__dirname, "../dist/rou3.js");
   let rou3Code = "";
   try {
-    rou3Code = fs2.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+    rou3Code = fs2__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);
   }
   let routesVersion = Math.random().toString(36).substring(7);
+  let agentsVersion = Math.random().toString(36).substring(7);
+  let registryVersion = Math.random().toString(36).substring(7);
   function getWorkerEnvironment(server) {
     const envNames = Object.keys(server.environments);
     const workerEnvName = envNames.find((name) => name !== "client");
@@ -2142,120 +4522,269 @@ function agentbuilder(options = {}) {
     }
     return server.environments[workerEnvName];
   }
-  function reloadToolsModule(server) {
+  function invalidateVirtualModule(server, virtualId, resolvedId) {
+    const invalidatedEnvs = [];
+    for (const [envName, env] of Object.entries(server.environments)) {
+      let mod = env.moduleGraph.getModuleById(resolvedId);
+      if (!mod) {
+        mod = env.moduleGraph.urlToModuleMap.get(virtualId);
+      }
+      if (!mod) {
+        mod = env.moduleGraph.urlToModuleMap.get(resolvedId);
+      }
+      if (mod) {
+        console.log(`[HMR] Found ${virtualId} in ${envName} environment, invalidating`);
+        env.moduleGraph.invalidateModule(mod);
+        invalidatedEnvs.push(envName);
+        for (const importer of mod.importers) {
+          env.moduleGraph.invalidateModule(importer);
+          console.log(`[HMR] Also invalidated importer: ${importer.url}`);
+        }
+      }
+    }
+    return {
+      invalidatedAny: invalidatedEnvs.length > 0,
+      environments: invalidatedEnvs
+    };
+  }
+  async function reloadToolsModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const toolsModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_TOOLS_ID
-    );
-    if (toolsModule) {
-      workerEnv.reloadModule(toolsModule);
+    try {
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_TOOLS_ID,
+        RESOLVED_VIRTUAL_TOOLS_ID
+      );
+      if (!invalidatedAny) {
+        const toolsModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_TOOLS_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(toolsModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:tools-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadToolsModule error:", err);
+      return false;
     }
-    return false;
   }
-  function reloadRoutesModule(server) {
+  async function reloadRoutesModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const routesModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_ROUTES_ID
-    );
-    if (routesModule) {
+    try {
       routesVersion = Math.random().toString(36).substring(7);
-      workerEnv.reloadModule(routesModule);
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_ROUTES_ID,
+        RESOLVED_VIRTUAL_ROUTES_ID
+      );
+      if (!invalidatedAny) {
+        const routesModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_ROUTES_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(routesModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:routes-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadRoutesModule error:", err);
+      return false;
     }
-    return false;
   }
-  function reloadHooksModule(server) {
+  async function reloadHooksModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const hooksModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_HOOKS_ID
-    );
-    if (hooksModule) {
-      workerEnv.reloadModule(hooksModule);
+    try {
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_HOOKS_ID,
+        RESOLVED_VIRTUAL_HOOKS_ID
+      );
+      if (!invalidatedAny) {
+        const hooksModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_HOOKS_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(hooksModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:hooks-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadHooksModule error:", err);
+      return false;
     }
-    return false;
   }
   async function reloadModelsModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const modelsModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_MODELS_ID
-    );
-    if (modelsModule) {
-      await workerEnv.reloadModule(modelsModule);
+    try {
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_MODELS_ID,
+        RESOLVED_VIRTUAL_MODELS_ID
+      );
+      if (!invalidatedAny) {
+        const modelsModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_MODELS_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(modelsModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:models-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadModelsModule error:", err);
+      return false;
     }
-    return false;
   }
   async function reloadPromptsModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const promptsModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_PROMPTS_ID
-    );
-    if (promptsModule) {
-      await workerEnv.reloadModule(promptsModule);
+    try {
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_PROMPTS_ID,
+        RESOLVED_VIRTUAL_PROMPTS_ID
+      );
+      if (!invalidatedAny) {
+        const promptsModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_PROMPTS_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(promptsModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:prompts-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadPromptsModule error:", err);
+      return false;
     }
-    return false;
   }
   async function reloadAgentsModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const agentsModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_AGENTS_ID
-    );
-    if (agentsModule) {
-      await workerEnv.reloadModule(agentsModule);
+    try {
+      agentsVersion = Math.random().toString(36).substring(7);
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_AGENTS_ID,
+        RESOLVED_VIRTUAL_AGENTS_ID
+      );
+      if (!invalidatedAny) {
+        const agentsModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_AGENTS_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(agentsModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       server.ws.send({
         type: "custom",
         event: "agent:agents-updated",
         data: { timestamp: Date.now() }
       });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadAgentsModule error:", err);
+      return false;
     }
-    return false;
   }
   async function reloadRouterModule(server) {
     const workerEnv = getWorkerEnvironment(server);
     if (!workerEnv) return false;
-    const routerModule = workerEnv.moduleGraph.getModuleById(
-      RESOLVED_VIRTUAL_ROUTER_ID
-    );
-    if (routerModule) {
-      await workerEnv.reloadModule(routerModule);
+    try {
+      routesVersion = Math.random().toString(36).substring(7);
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_ROUTES_ID,
+        RESOLVED_VIRTUAL_ROUTES_ID
+      );
+      invalidateVirtualModule(
+        server,
+        VIRTUAL_ROUTER_ID,
+        RESOLVED_VIRTUAL_ROUTER_ID
+      );
+      if (!invalidatedAny) {
+        const routerModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_ROUTES_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(routerModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
+      return true;
+    } catch (err) {
+      console.error("[HMR] reloadRouterModule error:", err);
+      return false;
+    }
+  }
+  async function reloadRegistryModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    try {
+      registryVersion = Math.random().toString(36).substring(7);
+      const { invalidatedAny } = invalidateVirtualModule(
+        server,
+        VIRTUAL_REGISTRY_ID,
+        RESOLVED_VIRTUAL_REGISTRY_ID
+      );
+      if (!invalidatedAny) {
+        const registryModule = await workerEnv.moduleGraph.ensureEntryFromUrl(
+          VIRTUAL_REGISTRY_ID
+        );
+        workerEnv.moduleGraph.invalidateModule(registryModule);
+      }
+      workerEnv.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
       return true;
+    } catch (err) {
+      console.error("[HMR] reloadRegistryModule error:", err);
+      return false;
     }
-    return false;
   }
   function handleFileChange(file, server) {
     const isToolFile = file.startsWith(toolsDir) && file.endsWith(".ts");
@@ -2286,6 +4815,7 @@ function agentbuilder(options = {}) {
     }
     if (isHookFile) {
       reloadHooksModule(server);
+      reloadRoutesModule(server);
     }
   }
   return {
@@ -2297,28 +4827,37 @@ function agentbuilder(options = {}) {
         "@standardagents/builder/runtime",
         "@standardagents/builder/built-in-routes",
         "@standardagents/builder/image-processing",
+        "@standardagents/builder/packing",
         // WASM image processing deps - must be excluded to avoid pre-bundle cache issues
         "@cf-wasm/photon",
         "@cf-wasm/photon/workerd",
         "@standardagents/sip",
         // sip's jsquash dependencies (WASM-based decoders)
         "@jsquash/avif",
-        "@jsquash/webp"
+        "@jsquash/webp",
+        // Rollup and plugins - only used by CLI pack command, not in dev/production
+        "rollup",
+        "@rollup/plugin-commonjs",
+        "@rollup/plugin-node-resolve",
+        "rollup-plugin-esbuild",
+        "fsevents",
+        "typescript"
       ];
       const depsToInclude = [
         "zod",
         "openai",
+        "magic-string",
         "@standardagents/spec"
       ];
-      const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const builderClientDir = path3.resolve(
+      const builderClientDir = path8__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
       return {
         // Set publicDir to builder's client assets so Cloudflare plugin preserves assets config
-        publicDir: fs2.existsSync(builderClientDir) ? builderClientDir : void 0,
+        publicDir: fs2__default.existsSync(builderClientDir) ? builderClientDir : void 0,
         optimizeDeps: {
           // Exclude our packages from pre-bundling - they contain cloudflare:workers imports
           // that cannot be resolved during dependency optimization
@@ -2334,6 +4873,12 @@ function agentbuilder(options = {}) {
             "@standardagents/builder/runtime",
             "@standardagents/builder/built-in-routes"
           ]
+        },
+        // Suppress sourcemap warnings for packages without source maps (like typescript)
+        server: {
+          sourcemapIgnoreList: (sourcePath) => {
+            return sourcePath.includes("node_modules/typescript") || sourcePath.includes("node_modules/.pnpm/typescript");
+          }
         }
       };
     },
@@ -2344,13 +4889,21 @@ function agentbuilder(options = {}) {
         "@standardagents/builder/runtime",
         "@standardagents/builder/built-in-routes",
         "@standardagents/builder/image-processing",
+        "@standardagents/builder/packing",
         // WASM image processing deps
         "@cf-wasm/photon",
         "@cf-wasm/photon/workerd",
         "@standardagents/sip",
         // sip's jsquash dependencies (WASM-based decoders)
         "@jsquash/avif",
-        "@jsquash/webp"
+        "@jsquash/webp",
+        // Rollup and plugins - only used by CLI pack command, not in dev/production
+        "rollup",
+        "@rollup/plugin-commonjs",
+        "@rollup/plugin-node-resolve",
+        "rollup-plugin-esbuild",
+        "fsevents",
+        "typescript"
       ];
       const depsToInclude = [
         "zod",
@@ -2358,6 +4911,7 @@ function agentbuilder(options = {}) {
         "zod/v4",
         "zod/v4/core",
         "openai",
+        "magic-string",
         "@standardagents/spec"
       ];
       config.optimizeDeps = config.optimizeDeps || {};
@@ -2401,6 +4955,9 @@ function agentbuilder(options = {}) {
       if (id === VIRTUAL_PROVIDERS_ID) {
         return RESOLVED_VIRTUAL_PROVIDERS_ID;
       }
+      if (id === VIRTUAL_REGISTRY_ID) {
+        return RESOLVED_VIRTUAL_REGISTRY_ID;
+      }
       if (id === VIRTUAL_BUILDER_ID) {
         return RESOLVED_VIRTUAL_BUILDER_ID;
       }
@@ -2440,7 +4997,7 @@ ${toolsCode}
     /* v${routesVersion} */ async () => (await import("${importPath}")).default
   );`;
         }).join("\n");
-        return `// Inline rou3 router code (no external imports)
+        return `// Inline rou3 router code (no external imports) /* v${routesVersion} */
 ${rou3Code}
 
 import { registerBuiltInRoutes } from "@standardagents/builder/built-in-routes";
@@ -2450,6 +5007,7 @@ import { hooks } from "virtual:@standardagents-hooks";
 import { models, modelNames } from "virtual:@standardagents-models";
 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 { isThreadEndpoint } from "@standardagents/spec";
 
@@ -2462,7 +5020,8 @@ const PUBLIC_ROUTES = [
   '/api/auth/oauth/github',
   '/api/auth/oauth/google',
   '/api/auth/oauth/github/callback',
-  '/api/auth/oauth/google/callback'
+  '/api/auth/oauth/google/callback',
+  '/api/hooks'  // Hook metadata is safe to expose publicly
 ];
 
 // Check if a route is public (no auth required)
@@ -2554,7 +5113,7 @@ export async function router(request, env) {
   const router = createRouter();
 
   // Register built-in API routes with runtime data
-  registerBuiltInRoutes(router, { config, tools, models, modelNames, prompts, promptNames, agents, agentNames });
+  registerBuiltInRoutes(router, { config, tools, hooks, models, modelNames, prompts, promptNames, agents, agentNames, registry });
 
   // Register user thread API routes
 ${threadRouteCode}
@@ -2678,28 +5237,30 @@ async function serveUI(pathname, env) {
       }
       if (id === RESOLVED_VIRTUAL_HOOKS_ID) {
         const hooks = await scanHooksDirectory(hooksDir);
-        const hooksCode = hooks.map(({ name, importPath }) => {
-          return `  "${name}": async () => {
+        const hooksCode = hooks.map(({ id: hookId, hook, importPath }) => {
+          return `  "${hookId}": async () => {
     try {
       return (await import("${importPath}")).default;
     } catch (error) {
-      console.error('[Hooks] Failed to import hook ${name}:', error);
+      console.error('[Hooks] Failed to import hook ${hookId}:', error);
       return null;
     }
   },`;
         }).join("\n");
         return `// Virtual agent hooks module
+// Hook registry keyed by hook ID
+// Each loader returns: { hook: string, id: string, execute: Function }
 export const hooks = {
 ${hooksCode}
 };`;
       }
       if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
-        const relativeToolsDir = path3.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
-        const relativeHooksDir = path3.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
-        const relativeApiDir = path3.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
-        const relativeModelsDir = path3.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
-        const relativePromptsDir = path3.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
-        const relativeAgentsDir = path3.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
+        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 relativePromptsDir = path8__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
+        const relativeAgentsDir = path8__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
         return `// Virtual agent config module
 export const config = {
   toolsDir: "${relativeToolsDir}",
@@ -2762,7 +5323,9 @@ export const promptNames = ${JSON.stringify(prompts.filter((p) => !p.error).map(
 `;
       }
       if (id === RESOLVED_VIRTUAL_AGENTS_ID) {
+        console.log(`[vite-plugin-agent] load() called for agents module (v${agentsVersion})`);
         const agents = await scanAgentsDirectory(agentsDir);
+        console.log(`[vite-plugin-agent] Found ${agents.length} agents:`, agents.map((a) => a.name));
         const agentsCode = agents.map(({ name, importPath, error }) => {
           if (error) {
             const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
@@ -2778,7 +5341,7 @@ export const promptNames = ${JSON.stringify(prompts.filter((p) => !p.error).map(
   },`;
           }
         }).join("\n");
-        return `// Virtual agent agents module
+        return `// Virtual agent agents module /* v${agentsVersion} */
 export const agents = {
 ${agentsCode}
 };
@@ -2803,36 +5366,192 @@ export const agentNames = ${JSON.stringify(agents.filter((a) => !a.error).map((a
   },`;
           }
         }).join("\n");
-        return `// Virtual agent effects module
-export const effects = {
-${effectsCode}
-};
+        return `// Virtual agent effects module
+export const effects = {
+${effectsCode}
+};
+
+export const effectNames = ${JSON.stringify(effects.filter((e) => !e.error).map((e) => e.name))};
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_PROVIDERS_ID) {
+        const firstPartyProviders = [
+          { name: "openai", package: "@standardagents/openai", label: "OpenAI", envKey: "OPENAI_API_KEY" },
+          { name: "openrouter", package: "@standardagents/openrouter", label: "OpenRouter", envKey: "OPENROUTER_API_KEY" }
+        ];
+        const customProviders = (options.providers || []).map((pkg) => ({
+          name: pkg.split("/").pop() || pkg,
+          package: pkg,
+          label: pkg.split("/").pop() || pkg,
+          envKey: `${(pkg.split("/").pop() || pkg).toUpperCase().replace(/-/g, "_")}_API_KEY`,
+          isCustom: true
+        }));
+        const allProviders = [...firstPartyProviders, ...customProviders];
+        return `// Virtual providers module - lists available LLM provider packages
+export const providers = ${JSON.stringify(allProviders, null, 2)};
+
+export const providerNames = ${JSON.stringify(allProviders.map((p) => p.name))};
+
+// Provider factories - dynamic imports for code splitting
+export const providerFactories = {
+${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package}")).${p.name},`).join("\n")}
+};
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_REGISTRY_ID) {
+        console.log(`[vite-plugin-agent] load() called for registry module (v${registryVersion})`);
+        const tools = await scanToolsDirectory(toolsDir);
+        const hooks = await scanHooksDirectory(hooksDir);
+        const models = await scanModelsDirectory(modelsDir);
+        const prompts = await scanPromptsDirectory(promptsDir);
+        const agents = await scanAgentsDirectory(agentsDir);
+        const toAbsolutePath = (relativePath) => {
+          if (relativePath.startsWith("./")) {
+            return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+          }
+          return relativePath;
+        };
+        const globalToolsCode = tools.filter((t) => !t.error).map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${name}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
+        const globalPromptsCode = prompts.filter((p) => !p.error).map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${name}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
+        const globalModelsCode = models.filter((m) => !m.error).map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${name}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
+        const globalAgentsCode = agents.filter((a) => !a.error).map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${name}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
+        const globalHooksCode = hooks.map(({ id: id2, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `    "${id2}": async () => (await import("${absPath}")).default,`;
+        }).join("\n");
+        const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+        const packedPackages = [];
+        if (fs2__default.existsSync(packedDir)) {
+          console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
+          const pkgDirs = fs2__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+          console.log(`[vite-plugin-agent] Found package dirs: ${pkgDirs.join(", ")}`);
+          for (const pkgDirName of pkgDirs) {
+            const pkgPath = path8__default.join(packedDir, pkgDirName);
+            const pkgJsonPath = path8__default.join(pkgPath, "package.json");
+            if (fs2__default.existsSync(pkgJsonPath)) {
+              try {
+                const pkgJson = JSON.parse(fs2__default.readFileSync(pkgJsonPath, "utf-8"));
+                console.log(`[vite-plugin-agent] Loaded ${pkgDirName} package.json, standardagent:`, pkgJson.standardagent);
+                if (!pkgJson.standardagent) {
+                  continue;
+                }
+                const mainEntry = pkgJson.main || "./dist/index.js";
+                const outputDir2 = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+                const scanPackedDir = async (subDir) => {
+                  const fullPath = path8__default.join(pkgPath, outputDir2, subDir);
+                  if (!fs2__default.existsSync(fullPath)) return [];
+                  const files = fs2__default.readdirSync(fullPath).filter((f) => f.endsWith(".js") || f.endsWith(".ts")).map((f) => ({
+                    name: f.replace(/\.(js|ts)$/, ""),
+                    path: path8__default.join(fullPath, f).replace(/\\/g, "/")
+                  }));
+                  return files;
+                };
+                const pkg = {
+                  packageId: pkgJson.name,
+                  version: pkgJson.version,
+                  entryAgents: pkgJson.standardagent.entryAgents || [],
+                  items: {
+                    agents: await scanPackedDir("agents"),
+                    prompts: await scanPackedDir("prompts"),
+                    tools: await scanPackedDir("tools"),
+                    models: await scanPackedDir("models"),
+                    hooks: await scanPackedDir("hooks")
+                  }
+                };
+                console.log(`[vite-plugin-agent] Scanned package ${pkgJson.name}:`, pkg.items.agents);
+                packedPackages.push(pkg);
+              } catch (err) {
+                console.warn(`[vite-plugin-agent] Failed to load packed package ${pkgDirName}:`, err);
+              }
+            }
+          }
+        } else {
+          console.log(`[vite-plugin-agent] Packed directory does not exist: ${packedDir}`);
+        }
+        console.log(`[vite-plugin-agent] Total packed packages found: ${packedPackages.length}`);
+        const packagesCode = packedPackages.map((pkg) => {
+          const signature = JSON.stringify({
+            packageId: pkg.packageId,
+            version: pkg.version,
+            source: "local",
+            packedAt: Date.now()
+          });
+          const genLoaders = (items) => items.map(
+            (item) => `      "${item.name}": async () => {
+        const mod = await import("${item.path}");
+        return { ...mod.default, __package: ${signature} };
+      },`
+          ).join("\n");
+          return `  "${pkg.packageId}": {
+    agents: {
+${genLoaders(pkg.items.agents)}
+    },
+    prompts: {
+${genLoaders(pkg.items.prompts)}
+    },
+    tools: {
+${genLoaders(pkg.items.tools)}
+    },
+    models: {
+${genLoaders(pkg.items.models)}
+    },
+    hooks: {
+${genLoaders(pkg.items.hooks)}
+    },
+    entryAgents: ${JSON.stringify(pkg.entryAgents)},
+    signature: ${signature},
+  },`;
+        }).join("\n");
+        return `// Virtual namespaced registry module /* v${registryVersion} */
+// Provides global namespace + packed package namespaces for namespace isolation
 
-export const effectNames = ${JSON.stringify(effects.filter((e) => !e.error).map((e) => e.name))};
-`;
-      }
-      if (id === RESOLVED_VIRTUAL_PROVIDERS_ID) {
-        const firstPartyProviders = [
-          { name: "openai", package: "@standardagents/openai", label: "OpenAI", envKey: "OPENAI_API_KEY" },
-          { name: "openrouter", package: "@standardagents/openrouter", label: "OpenRouter", envKey: "OPENROUTER_API_KEY" }
-        ];
-        const customProviders = (options.providers || []).map((pkg) => ({
-          name: pkg.split("/").pop() || pkg,
-          package: pkg,
-          label: pkg.split("/").pop() || pkg,
-          envKey: `${(pkg.split("/").pop() || pkg).toUpperCase().replace(/-/g, "_")}_API_KEY`,
-          isCustom: true
-        }));
-        const allProviders = [...firstPartyProviders, ...customProviders];
-        return `// Virtual providers module - lists available LLM provider packages
-export const providers = ${JSON.stringify(allProviders, null, 2)};
+export const registry = {
+  global: {
+    agents: {
+${globalAgentsCode}
+    },
+    prompts: {
+${globalPromptsCode}
+    },
+    tools: {
+${globalToolsCode}
+    },
+    models: {
+${globalModelsCode}
+    },
+    hooks: {
+${globalHooksCode}
+    },
+  },
+  packages: {
+${packagesCode}
+  },
+};
 
-export const providerNames = ${JSON.stringify(allProviders.map((p) => p.name))};
+// Helper to get all visible agent names (global + entry points)
+export function getVisibleAgentNames() {
+  const globalAgents = Object.keys(registry.global.agents);
+  const entryPoints = Object.values(registry.packages)
+    .flatMap(pkg => pkg.entryAgents);
+  return [...new Set([...globalAgents, ...entryPoints])];
+}
 
-// Provider factories - dynamic imports for code splitting
-export const providerFactories = {
-${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package}")).${p.name},`).join("\n")}
-};
+// Helper to get all visible tool names (global only - packed tools are internal)
+export function getVisibleToolNames() {
+  return Object.keys(registry.global.tools);
+}
 `;
       }
       if (id === RESOLVED_VIRTUAL_BUILDER_ID) {
@@ -2844,7 +5563,7 @@ ${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package
         const effects = await scanEffectsDirectory(effectsDir);
         const toAbsolutePath = (relativePath) => {
           if (relativePath.startsWith("./")) {
-            return path3.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+            return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
           }
           return relativePath;
         };
@@ -2864,13 +5583,13 @@ ${allProviders.map((p) => `  "${p.name}": async () => (await import("${p.package
   },`;
           }
         }).join("\n");
-        const hooksCode = hooks.map(({ name, importPath }) => {
+        const hooksCode = hooks.map(({ id: id2, importPath }) => {
           const absPath = toAbsolutePath(importPath);
-          return `  "${name}": async () => {
+          return `  "${id2}": async () => {
     try {
       return (await import("${absPath}")).default;
     } catch (error) {
-      console.error('[Hooks] Failed to import hook ${name}:', error);
+      console.error('[Hooks] Failed to import hook ${id2}:', error);
       return null;
     }
   },`;
@@ -2953,6 +5672,9 @@ import { initWithWasmModule as _initSipWasm } from '@standardagents/sip';
 // Re-export router from virtual:@standardagents-routes
 export { router } from 'virtual:@standardagents-routes';
 
+// Import namespaced registry for packed agent support
+import { registry as _registry } from 'virtual:@standardagents-registry';
+
 // Registry objects
 const _tools = {
 ${toolsCode}
@@ -3016,6 +5738,10 @@ export class DurableThread extends _BaseDurableThread {
   effects() {
     return _effects;
   }
+
+  registry() {
+    return _registry;
+  }
 }
 
 /**
@@ -3046,6 +5772,10 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
   effects() {
     return _effects;
   }
+
+  registry() {
+    return _registry;
+  }
 }
 `;
       }
@@ -3078,53 +5808,6 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
           pathWithoutMount = "/" + pathWithoutMount;
         }
         const method = req.method?.toUpperCase();
-        if (pathWithoutMount === "/api/models" && method === "GET") {
-          try {
-            const fs4 = await import('fs');
-            const files = fs4.existsSync(modelsDir) ? fs4.readdirSync(modelsDir).filter((f) => f.endsWith(".ts")) : [];
-            const modelList = files.map((file) => {
-              try {
-                const filePath = path3.join(modelsDir, file);
-                const content = fs4.readFileSync(filePath, "utf-8");
-                const parsed = parseModelFile(content);
-                if (!parsed || !parsed.name) return null;
-                const fallbackObjects = parsed.fallbacks.map((fallbackName, index) => ({
-                  id: fallbackName,
-                  name: fallbackName,
-                  order: index
-                }));
-                return {
-                  id: parsed.name,
-                  name: parsed.name,
-                  provider: parsed.provider,
-                  provider_id: parsed.provider,
-                  model: parsed.model,
-                  input_price: parsed.inputPrice,
-                  output_price: parsed.outputPrice,
-                  cached_price: parsed.cachedPrice,
-                  included_providers: parsed.includedProviders,
-                  fallbacks: fallbackObjects,
-                  providerTools: parsed.providerTools,
-                  capabilities: parsed.capabilities,
-                  created_at: Math.floor(Date.now() / 1e3)
-                };
-              } catch (error) {
-                console.error(`Error loading model ${file}:`, error);
-                return null;
-              }
-            });
-            const validModels = modelList.filter(Boolean);
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ models: validModels }));
-            return;
-          } catch (error) {
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ error: error.message || "Failed to list models" }));
-            return;
-          }
-        }
         if (pathWithoutMount === "/api/models" && method === "POST") {
           try {
             const rawBody = await parseRequestBody(req);
@@ -3199,7 +5882,7 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
                 await reloadPromptsModule(server);
               }
               await reloadRouterModule(server);
-              await new Promise((resolve) => setTimeout(resolve, 100));
+              await new Promise((resolve2) => setTimeout(resolve2, 100));
               res.statusCode = 200;
               res.setHeader("Content-Type", "application/json");
               res.end(JSON.stringify({
@@ -3249,90 +5932,6 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             return;
           }
         }
-        if (pathWithoutMount === "/api/prompts" && method === "GET") {
-          try {
-            const fs4 = await import('fs');
-            const files = fs4.existsSync(promptsDir) ? fs4.readdirSync(promptsDir).filter((f) => f.endsWith(".ts")) : [];
-            const modelFiles = fs4.existsSync(modelsDir) ? fs4.readdirSync(modelsDir).filter((f) => f.endsWith(".ts")) : [];
-            const modelMap = {};
-            for (const file of modelFiles) {
-              try {
-                const filePath = path3.join(modelsDir, file);
-                const content = fs4.readFileSync(filePath, "utf-8");
-                const name = content.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
-                const provider = content.match(/provider:\s*['"]([^'"]+)['"]/)?.[1];
-                if (name) {
-                  modelMap[name] = { name, provider: provider || "unknown" };
-                }
-              } catch (error) {
-              }
-            }
-            const promptList = files.map((file) => {
-              try {
-                const filePath = path3.join(promptsDir, file);
-                const content = fs4.readFileSync(filePath, "utf-8");
-                const getName2 = (c) => c.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
-                const getToolDescription = (c) => c.match(/toolDescription:\s*['"]([^'"]+)['"]/)?.[1];
-                const getModel2 = (c) => c.match(/model:\s*['"]([^'"]+)['"]/)?.[1];
-                const getIncludeChat = (c) => c.match(/includeChat:\s*(true|false)/)?.[1] === "true";
-                const getIncludePastTools = (c) => c.match(/includePastTools:\s*(true|false)/)?.[1] === "true";
-                const getParallelToolCalls = (c) => c.match(/parallelToolCalls:\s*(true|false)/)?.[1] === "true";
-                const getToolChoice = (c) => c.match(/toolChoice:\s*['"]([^'"]+)['"]/)?.[1];
-                const getTools = (c) => {
-                  const match = c.match(/tools:\s*\[([^\]]*)\]/);
-                  if (!match) return [];
-                  const items = match[1].match(/['"]([^'"]+)['"]/g);
-                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
-                };
-                const getPrompt = (c) => {
-                  const backtickMatch = c.match(/prompt:\s*`([\s\S]*?)`/);
-                  if (backtickMatch) return backtickMatch[1];
-                  const quotedMatch = c.match(/prompt:\s*['"]([^'"]*)['"]/);
-                  if (quotedMatch) return quotedMatch[1];
-                  const arrayMatch = c.match(/prompt:\s*(\[[\s\S]*?\])/);
-                  if (arrayMatch) return arrayMatch[1];
-                  return "";
-                };
-                const name = getName2(content);
-                if (!name) return null;
-                const modelId = getModel2(content);
-                const modelDef = modelId ? modelMap[modelId] : null;
-                return {
-                  id: name,
-                  name,
-                  tool_description: getToolDescription(content) || "",
-                  prompt: getPrompt(content),
-                  required_schema: null,
-                  // Complex to parse, skip for now
-                  model_id: modelId || "",
-                  model_name: modelDef?.name || modelId || "",
-                  model_provider: modelDef?.provider || "unknown",
-                  include_chat: getIncludeChat(content),
-                  include_past_tools: getIncludePastTools(content),
-                  parallel_tool_calls: getParallelToolCalls(content),
-                  tool_choice: getToolChoice(content) || "auto",
-                  tools: getTools(content),
-                  reasoning: null,
-                  // Complex to parse
-                  created_at: Math.floor(Date.now() / 1e3)
-                };
-              } catch (error) {
-                console.error(`Error loading prompt ${file}:`, error);
-                return null;
-              }
-            });
-            const validPrompts = promptList.filter(Boolean);
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ prompts: validPrompts }));
-            return;
-          } catch (error) {
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ error: error.message || "Failed to list prompts" }));
-            return;
-          }
-        }
         if (pathWithoutMount === "/api/prompts" && method === "POST") {
           try {
             const rawBody = await parseRequestBody(req);
@@ -3458,63 +6057,6 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             return;
           }
         }
-        if (pathWithoutMount === "/api/agents" && method === "GET") {
-          try {
-            const fs4 = await import('fs');
-            const files = fs4.existsSync(agentsDir) ? fs4.readdirSync(agentsDir).filter((f) => f.endsWith(".ts")) : [];
-            const agentList = files.map((file) => {
-              try {
-                const filePath = path3.join(agentsDir, file);
-                const content = fs4.readFileSync(filePath, "utf-8");
-                const getName2 = (c) => c.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
-                const getTitle = (c) => c.match(/title:\s*['"]([^'"]+)['"]/)?.[1];
-                const getType = (c) => c.match(/type:\s*['"]([^'"]+)['"]/)?.[1];
-                const getDefaultPrompt = (c) => c.match(/defaultPrompt:\s*['"]([^'"]+)['"]/)?.[1];
-                const getDefaultModel = (c) => c.match(/defaultModel:\s*['"]([^'"]+)['"]/)?.[1];
-                const getTools = (c) => {
-                  const match = c.match(/tools:\s*\[([^\]]*)\]/);
-                  if (!match) return [];
-                  const items = match[1].match(/['"]([^'"]+)['"]/g);
-                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
-                };
-                const getSidePrompt = (c, side) => {
-                  const sideRegex = new RegExp(`${side}:\\s*\\{([^}]+)\\}`, "s");
-                  const sideMatch = c.match(sideRegex);
-                  if (!sideMatch) return null;
-                  const promptMatch = sideMatch[1].match(/prompt:\s*['"]([^'"]+)['"]/);
-                  return promptMatch ? promptMatch[1] : null;
-                };
-                const name = getName2(content);
-                if (!name) return null;
-                return {
-                  id: name,
-                  name,
-                  title: getTitle(content) || name,
-                  type: getType(content) || "ai_human",
-                  default_prompt: getDefaultPrompt(content) || "",
-                  default_model: getDefaultModel(content) || "",
-                  tools: getTools(content),
-                  side_a_agent_prompt: getSidePrompt(content, "sideA"),
-                  side_b_agent_prompt: getSidePrompt(content, "sideB"),
-                  created_at: Math.floor(Date.now() / 1e3)
-                };
-              } catch (error) {
-                console.error(`Error loading agent ${file}:`, error);
-                return null;
-              }
-            });
-            const validAgents = agentList.filter(Boolean);
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ agents: validAgents }));
-            return;
-          } catch (error) {
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ error: error.message || "Failed to list agents" }));
-            return;
-          }
-        }
         if (pathWithoutMount === "/api/agents" && method === "POST") {
           try {
             const rawBody = await parseRequestBody(req);
@@ -3622,6 +6164,333 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             return;
           }
         }
+        const packAnalyzeMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)\/analyze$/);
+        if (packAnalyzeMatch && method === "GET") {
+          try {
+            const agentName = decodeURIComponent(packAnalyzeMatch[1]);
+            const packingService = new PackingService();
+            const rootDir = process.cwd();
+            const analysis = await packingService.analyzeAgent(agentName, rootDir);
+            if (analysis.errors.length > 0) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: analysis.errors.join("\n"),
+                warnings: analysis.warnings
+              }));
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(analysis));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to analyze agent" }));
+            return;
+          }
+        }
+        const packMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)$/);
+        if (packMatch && method === "POST") {
+          try {
+            const agentName = decodeURIComponent(packMatch[1]);
+            const body = await parseRequestBody(req);
+            const packingService = new PackingService();
+            const rootDir = process.cwd();
+            const outputDir2 = path8__default.join(rootDir, "agents", "packed");
+            const result = await packingService.pack({
+              agentName,
+              rootDir,
+              outputDir: outputDir2,
+              version: body.version,
+              packageId: body.packageId,
+              packageName: body.packageName,
+              license: body.license,
+              licenseOwner: body.licenseOwner,
+              itemSelections: body.itemSelections
+            });
+            if (!result.success) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: result.error,
+                warnings: result.warnings
+              }));
+              return;
+            }
+            reloadToolsModule(server);
+            reloadHooksModule(server);
+            await reloadAgentsModule(server);
+            await reloadPromptsModule(server);
+            await reloadModelsModule(server);
+            await reloadRegistryModule(server);
+            await reloadRouterModule(server);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(result));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to pack agent" }));
+            return;
+          }
+        }
+        const packDeleteMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)$/);
+        if (packDeleteMatch && method === "DELETE") {
+          try {
+            const packageId = decodeURIComponent(packDeleteMatch[1]);
+            const unpackingService = new UnpackingService();
+            const rootDir = process.cwd();
+            const packages = await unpackingService.listPackages(rootDir);
+            const pkg = packages.find((p) => p.packageId === packageId);
+            if (!pkg) {
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: `Package not found: ${packageId}` }));
+              return;
+            }
+            if (pkg.source !== "local") {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: "Cannot delete npm packages. Use npm uninstall instead." }));
+              return;
+            }
+            const fs9 = await import('fs');
+            fs9.rmSync(pkg.path, { recursive: true, force: true });
+            reloadToolsModule(server);
+            reloadHooksModule(server);
+            await reloadAgentsModule(server);
+            await reloadPromptsModule(server);
+            await reloadModelsModule(server);
+            await reloadRegistryModule(server);
+            await reloadRouterModule(server);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ success: true, packageId }));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to delete package" }));
+            return;
+          }
+        }
+        const packDownloadMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)\/download$/);
+        if (packDownloadMatch && method === "GET") {
+          try {
+            const packageId = decodeURIComponent(packDownloadMatch[1]);
+            const unpackingService = new UnpackingService();
+            const rootDir = process.cwd();
+            const packages = await unpackingService.listPackages(rootDir);
+            const pkg = packages.find((p) => p.packageId === packageId);
+            if (!pkg) {
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: `Package not found: ${packageId}` }));
+              return;
+            }
+            const { spawn } = await import('child_process');
+            const parentDir = path8__default.dirname(pkg.path);
+            const dirName = path8__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]);
+            tar.stdout.pipe(res);
+            tar.stderr.on("data", (data) => console.error("tar error:", data.toString()));
+            tar.on("error", (err) => {
+              console.error("Failed to spawn tar:", err);
+              if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Failed to create tarball" }));
+              }
+            });
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to download package" }));
+            return;
+          }
+        }
+        const packInfoMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)\/packed-info$/);
+        if (packInfoMatch && method === "GET") {
+          try {
+            const packageId = decodeURIComponent(packInfoMatch[1]);
+            const packingService = new PackingService();
+            const rootDir = process.cwd();
+            const info = packingService.getPackedInfo(packageId, rootDir);
+            if (!info) {
+              const availablePackages = packingService.listPackedPackages(rootDir);
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: `Packed package not found: ${packageId}`,
+                availablePackages
+              }));
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(info));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to read package info" }));
+            return;
+          }
+        }
+        const packPublishMatch = pathWithoutMount.match(/^\/api\/pack\/([^/]+)\/publish$/);
+        if (packPublishMatch && method === "POST") {
+          try {
+            const packageId = decodeURIComponent(packPublishMatch[1]);
+            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 (!fs2__default.existsSync(packageDir)) {
+              if (!fs2__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;
+              }
+              const dirs = fs2__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, "-")}`
+              );
+              if (!matchingDir) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                  error: `Package not found: ${packageId}. Available packages: ${dirs.join(", ") || "none"}`
+                }));
+                return;
+              }
+              packageDir = path8__default.join(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 (fs2__default.existsSync(devVarsPath)) {
+                const devVars = fs2__default.readFileSync(devVarsPath, "utf-8");
+                const match = devVars.match(/^NPM_TOKEN=(.+)$/m);
+                if (match) {
+                  token = match[1].trim();
+                  tokenSource = "environment";
+                }
+              }
+            }
+            if (!token) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: "npm token is required. Either provide a token in the request or set NPM_TOKEN in your .dev.vars or .env file."
+              }));
+              return;
+            }
+            const publishService = new NpmPublishService();
+            const result = await publishService.publish({
+              packageDir,
+              token,
+              registry: body.registry,
+              dryRun: body.dryRun
+            });
+            if (!result.success) {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error, output: result.output }));
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+              success: true,
+              packageName: result.packageName,
+              version: result.version,
+              output: result.output,
+              url: publishService.getPackageUrl(result.packageName, body.registry),
+              tokenSource
+            }));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to publish package" }));
+            return;
+          }
+        }
+        const unpackAnalyzeMatch = pathWithoutMount.match(/^\/api\/unpack\/([^/]+)\/analyze$/);
+        if (unpackAnalyzeMatch && method === "GET") {
+          try {
+            const packageId = decodeURIComponent(unpackAnalyzeMatch[1]);
+            const unpackingService = new UnpackingService();
+            const rootDir = process.cwd();
+            const analysis = await unpackingService.analyzeUnpack(packageId, rootDir);
+            if (analysis.errors.length > 0) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: analysis.errors.join("\n"),
+                warnings: analysis.warnings
+              }));
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(analysis));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to analyze package" }));
+            return;
+          }
+        }
+        const unpackMatch = pathWithoutMount.match(/^\/api\/unpack\/([^/]+)$/);
+        if (unpackMatch && method === "POST") {
+          try {
+            const packageId = decodeURIComponent(unpackMatch[1]);
+            const body = await parseRequestBody(req);
+            const unpackingService = new UnpackingService();
+            const rootDir = process.cwd();
+            const result = await unpackingService.unpack({
+              packageId,
+              rootDir,
+              deletePackage: body.deletePackage,
+              itemSelections: body.itemSelections
+            });
+            if (!result.success) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                error: result.error,
+                warnings: result.warnings
+              }));
+              return;
+            }
+            reloadToolsModule(server);
+            reloadHooksModule(server);
+            await reloadAgentsModule(server);
+            await reloadPromptsModule(server);
+            await reloadModelsModule(server);
+            await reloadRegistryModule(server);
+            await reloadRouterModule(server);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(result));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to unpack package" }));
+            return;
+          }
+        }
         if (pathWithoutMount.startsWith("/api/")) {
           next();
           return;
@@ -3646,23 +6515,23 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
         }
         const isStaticAsset = pathWithoutMount.startsWith("/assets/") || pathWithoutMount.startsWith("/vendor.js") || pathWithoutMount.startsWith("/vue.js") || pathWithoutMount.startsWith("/monaco.js") || pathWithoutMount.startsWith("/index.js") || pathWithoutMount.startsWith("/index.css") || pathWithoutMount.match(/\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico)$/);
         {
-          const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+          const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
           const isInDist = currentDir.endsWith("dist");
-          const clientDir = path3.resolve(
+          const clientDir = path8__default.resolve(
             currentDir,
             isInDist ? "./client" : "../dist/client"
           );
           let filePath;
           if (isStaticAsset) {
             const cleanUrl = pathWithoutMount.split("?")[0];
-            filePath = path3.join(clientDir, cleanUrl);
+            filePath = path8__default.join(clientDir, cleanUrl);
           } else {
-            filePath = path3.join(clientDir, "index.html");
+            filePath = path8__default.join(clientDir, "index.html");
           }
           try {
-            if (fs2.existsSync(filePath)) {
-              let content = fs2.readFileSync(filePath);
-              const ext = path3.extname(filePath).toLowerCase();
+            if (fs2__default.existsSync(filePath)) {
+              let content = fs2__default.readFileSync(filePath);
+              const ext = path8__default.extname(filePath).toLowerCase();
               if (ext === ".html") {
                 const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
                 let htmlContent = content.toString();
@@ -3700,28 +6569,28 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
     writeBundle(options2, bundle) {
       const outDir = options2.dir || "dist";
       const mountPath = mountPoint.slice(1);
-      const mountDir = mountPath ? path3.join(outDir, "../client", mountPath) : path3.join(outDir, "../client");
-      const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+      const mountDir = mountPath ? path8__default.join(outDir, "../client", mountPath) : path8__default.join(outDir, "../client");
+      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path3.resolve(
+      const clientDir = path8__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
-      if (!fs2.existsSync(clientDir)) {
+      if (!fs2__default.existsSync(clientDir)) {
         console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
         return;
       }
-      fs2.mkdirSync(mountDir, { recursive: true });
+      fs2__default.mkdirSync(mountDir, { recursive: true });
       function copyRecursive(src, dest) {
-        const entries = fs2.readdirSync(src, { withFileTypes: true });
+        const entries = fs2__default.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const srcPath = path3.join(src, entry.name);
-          const destPath = path3.join(dest, entry.name);
+          const srcPath = path8__default.join(src, entry.name);
+          const destPath = path8__default.join(dest, entry.name);
           if (entry.isDirectory()) {
-            fs2.mkdirSync(destPath, { recursive: true });
+            fs2__default.mkdirSync(destPath, { recursive: true });
             copyRecursive(srcPath, destPath);
           } else {
-            let content = fs2.readFileSync(srcPath);
+            let content = fs2__default.readFileSync(srcPath);
             if (entry.name === "index.html") {
               const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
               let htmlContent = content.toString();
@@ -3730,7 +6599,7 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs2.writeFileSync(destPath, content);
+            fs2__default.writeFileSync(destPath, content);
           }
         }
       }