@standardagents/builder 0.15.0 → 0.15.1

package/dist/plugin.js

@@ -1,7 +1,7 @@
-import * as fs7 from 'fs';
-import fs7__default from 'fs';
-import * as path7 from 'path';
-import path7__default from 'path';
+import * as fs8 from 'fs';
+import fs8__default from 'fs';
+import * as path8 from 'path';
+import path8__default from 'path';
 import { fileURLToPath } from 'url';
 import MagicString from 'magic-string';
 import { exec } from 'child_process';
@@ -40,15 +40,15 @@ function extractSchemaFields(content) {
 }
 function scanPromptsWithSchemas(dir) {
   const results = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path7__default.join(dir, entry.name);
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -64,15 +64,15 @@ function scanPromptsWithSchemas(dir) {
 }
 function scanAgentsWithSideA(dir) {
   const results = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path7__default.join(dir, entry.name);
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -92,15 +92,15 @@ function scanAgentsWithSideA(dir) {
 }
 function scanForNames(dir, useFilename = false) {
   const names = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return names;
   }
   try {
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path7__default.join(dir, entry.name);
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         if (useFilename) {
           const toolName = entry.name.replace(/\.ts$/, "");
           if (content.includes("defineTool")) {
@@ -121,18 +121,18 @@ function scanForNames(dir, useFilename = false) {
 }
 function scanHooksForIds(dir) {
   const hookIds = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return hookIds;
   }
   try {
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__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 = path7__default.join(dir, entry.name);
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const filePath = path8__default.join(dir, entry.name);
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/defineHook\s*\(\s*\{[^}]*id:\s*['"]([^'"]+)['"]/s);
         if (idMatch) {
           hookIds.push(idMatch[1]);
@@ -599,6 +599,34 @@ declare module 'virtual:@standardagents/builder' {
       property: string;
       promptName?: string;
     }): Promise<'text' | 'secret'>;
+    getInstanceEnv(): Promise<Record<string, string>>;
+    getInstanceEnvTypes(): Promise<Record<string, 'text' | 'secret'>>;
+    getInstanceEnvEntries(): Promise<Array<{
+      name: string;
+      value: string;
+      type: 'text' | 'secret';
+      created_at: number;
+      updated_at: number;
+    }>>;
+    patchInstanceEnv(params: {
+      env_patch?: Record<string, unknown> | null;
+      env_type_patch?: Record<string, unknown> | null;
+      env_delete?: string[] | null;
+    }): Promise<void>;
+    getUserEnv(userId: string): Promise<Record<string, string>>;
+    getUserEnvTypes(userId: string): Promise<Record<string, 'text' | 'secret'>>;
+    getUserEnvEntries(userId: string): Promise<Array<{
+      name: string;
+      value: string;
+      type: 'text' | 'secret';
+      created_at: number;
+      updated_at: number;
+    }>>;
+    patchUserEnv(userId: string, params: {
+      env_patch?: Record<string, unknown> | null;
+      env_type_patch?: Record<string, unknown> | null;
+      env_delete?: string[] | null;
+    }): Promise<void>;
     listThreads(params?: {
       agent_name?: string;
       user_id?: string;
@@ -756,44 +784,44 @@ declare module 'virtual:@standardagents/router' {
 `;
 }
 function ensureDir(dir) {
-  if (!fs7__default.existsSync(dir)) {
-    fs7__default.mkdirSync(dir, { recursive: true });
+  if (!fs8__default.existsSync(dir)) {
+    fs8__default.mkdirSync(dir, { recursive: true });
   }
 }
 function writeFileIfChanged(filePath, content) {
-  if (fs7__default.existsSync(filePath)) {
-    const existing = fs7__default.readFileSync(filePath, "utf-8");
+  if (fs8__default.existsSync(filePath)) {
+    const existing = fs8__default.readFileSync(filePath, "utf-8");
     if (existing === content) {
       return;
     }
   }
-  fs7__default.writeFileSync(filePath, content);
+  fs8__default.writeFileSync(filePath, content);
 }
 function generateTypes(config) {
   ensureDir(config.outputDir);
   const typesContent = generateTypesContent(config);
-  writeFileIfChanged(path7__default.join(config.outputDir, "types.d.ts"), typesContent);
+  writeFileIfChanged(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
   const virtualModuleContent = generateVirtualModuleContent();
-  writeFileIfChanged(path7__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
-  writeFileIfChanged(path7__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
-  writeFileIfChanged(path7__default.join(config.outputDir, ".gitignore"), "*\n");
+  writeFileIfChanged(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  writeFileIfChanged(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  writeFileIfChanged(path8__default.join(config.outputDir, ".gitignore"), "*\n");
 }
 function needsRegeneration(config) {
-  const typesPath = path7__default.join(config.outputDir, "types.d.ts");
-  if (!fs7__default.existsSync(typesPath)) {
+  const typesPath = path8__default.join(config.outputDir, "types.d.ts");
+  if (!fs8__default.existsSync(typesPath)) {
     return true;
   }
-  const typesMtime = fs7__default.statSync(typesPath).mtime;
+  const typesMtime = fs8__default.statSync(typesPath).mtime;
   const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir, config.hooksDir];
   for (const dir of dirs) {
-    if (!fs7__default.existsSync(dir)) {
+    if (!fs8__default.existsSync(dir)) {
       continue;
     }
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path7__default.join(dir, entry.name);
-        const fileMtime = fs7__default.statSync(filePath).mtime;
+        const filePath = path8__default.join(dir, entry.name);
+        const fileMtime = fs8__default.statSync(filePath).mtime;
         if (fileMtime > typesMtime) {
           return true;
         }
@@ -980,7 +1008,7 @@ function createHmrReloader() {
     versions,
     invalidateSourceFileModule(server, filePath) {
       if (!filePath) return;
-      const absolutePath = path7__default.resolve(filePath);
+      const absolutePath = path8__default.resolve(filePath);
       for (const [envName, env] of Object.entries(server.environments)) {
         const modules = env.moduleGraph.getModulesByFile(absolutePath);
         if (!modules) continue;
@@ -991,10 +1019,10 @@ function createHmrReloader() {
       }
     },
     invalidateSourceDirectoryModules(server, dirPath) {
-      if (!fs7__default.existsSync(dirPath)) return;
+      if (!fs8__default.existsSync(dirPath)) return;
       const scan = (currentDir) => {
-        for (const entry of fs7__default.readdirSync(currentDir, { withFileTypes: true })) {
-          const nextPath = path7__default.join(currentDir, entry.name);
+        for (const entry of fs8__default.readdirSync(currentDir, { withFileTypes: true })) {
+          const nextPath = path8__default.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             scan(nextPath);
           } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -1146,6 +1174,73 @@ function createHmrReloader() {
   };
   return reloader;
 }
+var STATE_RELATIVE_PATH = path8__default.join(".agents", "bootstrap-session.json");
+var PROJECT_ROOT_ENV_KEYS = ["INIT_CWD", "PWD", "npm_config_local_prefix"];
+function uniquePaths(paths) {
+  return Array.from(
+    new Set(
+      paths.filter((value) => !!value?.trim()).map((value) => path8__default.resolve(value))
+    )
+  );
+}
+function isBootstrapSessionRoute(routePath) {
+  return routePath === "/api/platform-auth/me" || routePath === "/api/platform-session" || routePath.startsWith("/api/platform-session/");
+}
+function hasSessionCookie(cookieHeader) {
+  const raw = Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader || "";
+  return /(?:^|;\s*)session=/.test(raw);
+}
+function mergeCookieHeader(cookieHeader, injectedCookie) {
+  const raw = Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader || "";
+  return raw ? `${raw}; ${injectedCookie}` : injectedCookie;
+}
+function loadLocalBootstrapSession(projectRoot) {
+  const statePath = path8__default.join(projectRoot, STATE_RELATIVE_PATH);
+  if (!fs8__default.existsSync(statePath)) return null;
+  try {
+    const parsed = JSON.parse(
+      fs8__default.readFileSync(statePath, "utf-8")
+    );
+    if (parsed.version !== 1) return null;
+    if (!parsed.endpoint || !parsed.user?.id || !parsed.account?.id) return null;
+    if (!parsed.session_cookie || typeof parsed.session_cookie !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function loadLocalBootstrapSessionFromEnv(env) {
+  return null;
+}
+function findLocalBootstrapSession(projectRoot, env) {
+  const envSession = loadLocalBootstrapSessionFromEnv();
+  if (envSession) {
+    return {
+      projectRoot: projectRoot ? path8__default.resolve(projectRoot) : process.cwd(),
+      session: envSession
+    };
+  }
+  const candidates = uniquePaths([
+    projectRoot,
+    process.cwd(),
+    ...PROJECT_ROOT_ENV_KEYS.map((key) => process.env[key])
+  ]);
+  for (const candidate of candidates) {
+    const session = loadLocalBootstrapSession(candidate);
+    if (session) {
+      return {
+        projectRoot: candidate,
+        session
+      };
+    }
+  }
+  return null;
+}
+function resolveLocalBootstrapCookie(projectRoot, routePath, cookieHeader) {
+  if (!isBootstrapSessionRoute(routePath)) return null;
+  if (hasSessionCookie(cookieHeader)) return null;
+  return findLocalBootstrapSession(projectRoot)?.session.session_cookie ?? null;
+}
 
 // src/sdk/generators/generateModelFile.ts
 function generateModelFile(data, options) {
@@ -1766,19 +1861,19 @@ function nameToFilename(name) {
 }
 function getModelFilePath(modelsDir, name) {
   const filename = nameToFilename(name);
-  return path7__default.join(modelsDir, `${filename}.ts`);
+  return path8__default.join(modelsDir, `${filename}.ts`);
 }
 function modelExists(modelsDir, name) {
   const filePath = getModelFilePath(modelsDir, name);
-  return fs7__default.existsSync(filePath);
+  return fs8__default.existsSync(filePath);
 }
 async function saveModel(modelsDir, data, overwrite = false, providerPackageMap = defaultProviderPackageMap) {
   try {
-    if (!fs7__default.existsSync(modelsDir)) {
-      fs7__default.mkdirSync(modelsDir, { recursive: true });
+    if (!fs8__default.existsSync(modelsDir)) {
+      fs8__default.mkdirSync(modelsDir, { recursive: true });
     }
     const filePath = getModelFilePath(modelsDir, data.name);
-    if (!overwrite && fs7__default.existsSync(filePath)) {
+    if (!overwrite && fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file already exists: ${filePath}. Use update to modify existing models.`
@@ -1795,7 +1890,7 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
       providerName: providerInfo.name,
       providerPackage: providerInfo.package
     });
-    await fs7__default.promises.writeFile(filePath, content, "utf-8");
+    await fs8__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -1810,13 +1905,13 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
 async function deleteModel(modelsDir, name) {
   try {
     const filePath = getModelFilePath(modelsDir, name);
-    if (!fs7__default.existsSync(filePath)) {
+    if (!fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file not found: ${filePath}`
       };
     }
-    await fs7__default.promises.unlink(filePath);
+    await fs8__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2077,26 +2172,26 @@ function transformPromptData(data) {
 }
 function getPromptFilePath(promptsDir, name) {
   const filename = nameToFilename(name);
-  return path7__default.join(promptsDir, `${filename}.ts`);
+  return path8__default.join(promptsDir, `${filename}.ts`);
 }
 function promptExists(promptsDir, name) {
   const filePath = getPromptFilePath(promptsDir, name);
-  return fs7__default.existsSync(filePath);
+  return fs8__default.existsSync(filePath);
 }
 async function savePrompt(promptsDir, data, overwrite = false) {
   try {
-    if (!fs7__default.existsSync(promptsDir)) {
-      fs7__default.mkdirSync(promptsDir, { recursive: true });
+    if (!fs8__default.existsSync(promptsDir)) {
+      fs8__default.mkdirSync(promptsDir, { recursive: true });
     }
     const filePath = getPromptFilePath(promptsDir, data.name);
-    if (!overwrite && fs7__default.existsSync(filePath)) {
+    if (!overwrite && fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
       };
     }
     const content = generatePromptFile(data);
-    await fs7__default.promises.writeFile(filePath, content, "utf-8");
+    await fs8__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -2111,13 +2206,13 @@ async function savePrompt(promptsDir, data, overwrite = false) {
 async function deletePrompt(promptsDir, name) {
   try {
     const filePath = getPromptFilePath(promptsDir, name);
-    if (!fs7__default.existsSync(filePath)) {
+    if (!fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${filePath}`
       };
     }
-    await fs7__default.promises.unlink(filePath);
+    await fs8__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2133,25 +2228,25 @@ async function renamePrompt(promptsDir, oldName, newName) {
   try {
     const oldFilePath = getPromptFilePath(promptsDir, oldName);
     const newFilePath = getPromptFilePath(promptsDir, newName);
-    if (!fs7__default.existsSync(oldFilePath)) {
+    if (!fs8__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${oldFilePath}`
       };
     }
-    if (fs7__default.existsSync(newFilePath)) {
+    if (fs8__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${newFilePath}`
       };
     }
-    const content = await fs7__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs7__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs7__default.promises.unlink(oldFilePath);
+    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs8__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -2451,15 +2546,15 @@ function transformAgentData(data) {
 }
 function getAgentFilePath(agentsDir, name) {
   const filename = nameToFilename(name);
-  return path7__default.join(agentsDir, `${filename}.ts`);
+  return path8__default.join(agentsDir, `${filename}.ts`);
 }
 function agentExists(agentsDir, name) {
   const filePath = getAgentFilePath(agentsDir, name);
-  return fs7__default.existsSync(filePath);
+  return fs8__default.existsSync(filePath);
 }
 function extractAgentMetadata(filePath) {
   try {
-    const content = fs7__default.readFileSync(filePath, "utf-8");
+    const content = fs8__default.readFileSync(filePath, "utf-8");
     const metadata = {};
     const packageNameMatch = content.match(/packageName:\s*['"]([^'"]+)['"]/);
     if (packageNameMatch) metadata.packageName = packageNameMatch[1];
@@ -2476,17 +2571,17 @@ function extractAgentMetadata(filePath) {
 }
 async function saveAgent(agentsDir, data, overwrite = false) {
   try {
-    if (!fs7__default.existsSync(agentsDir)) {
-      fs7__default.mkdirSync(agentsDir, { recursive: true });
+    if (!fs8__default.existsSync(agentsDir)) {
+      fs8__default.mkdirSync(agentsDir, { recursive: true });
     }
     const filePath = getAgentFilePath(agentsDir, data.name);
-    if (!overwrite && fs7__default.existsSync(filePath)) {
+    if (!overwrite && fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
       };
     }
-    if (overwrite && fs7__default.existsSync(filePath)) {
+    if (overwrite && fs8__default.existsSync(filePath)) {
       const existingMetadata = extractAgentMetadata(filePath);
       if (existingMetadata.packageName && !data.packageName) {
         data.packageName = existingMetadata.packageName;
@@ -2502,7 +2597,7 @@ async function saveAgent(agentsDir, data, overwrite = false) {
       }
     }
     const content = generateAgentFile(data);
-    await fs7__default.promises.writeFile(filePath, content, "utf-8");
+    await fs8__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -2517,13 +2612,13 @@ async function saveAgent(agentsDir, data, overwrite = false) {
 async function deleteAgent(agentsDir, name) {
   try {
     const filePath = getAgentFilePath(agentsDir, name);
-    if (!fs7__default.existsSync(filePath)) {
+    if (!fs8__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file not found: ${filePath}`
       };
     }
-    await fs7__default.promises.unlink(filePath);
+    await fs8__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -2539,25 +2634,25 @@ async function renameModel(modelsDir, oldName, newName) {
   try {
     const oldFilePath = getModelFilePath(modelsDir, oldName);
     const newFilePath = getModelFilePath(modelsDir, newName);
-    if (!fs7__default.existsSync(oldFilePath)) {
+    if (!fs8__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Model file not found: ${oldFilePath}`
       };
     }
-    if (fs7__default.existsSync(newFilePath)) {
+    if (fs8__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Model file already exists: ${newFilePath}`
       };
     }
-    const content = await fs7__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs7__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs7__default.promises.unlink(oldFilePath);
+    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs8__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -2571,17 +2666,17 @@ async function renameModel(modelsDir, oldName, newName) {
 }
 async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
   const updatedFiles = [];
-  if (!fs7__default.existsSync(promptsDir)) {
+  if (!fs8__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs7__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path7__default.join(promptsDir, file);
-    let content = await fs7__default.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(promptsDir, file);
+    let content = await fs8__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 fs7__default.promises.writeFile(filePath, content, "utf-8");
+      await fs8__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2589,13 +2684,13 @@ async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModel
 }
 async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs7__default.existsSync(promptsDir)) {
+  if (!fs8__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs7__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path7__default.join(promptsDir, file);
-    let content = await fs7__default.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(promptsDir, file);
+    let content = await fs8__default.promises.readFile(filePath, "utf-8");
     let modified = false;
     const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
     const newContent = content.replace(toolsArrayRegex, (match) => {
@@ -2608,7 +2703,7 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
       return replaced;
     });
     if (modified) {
-      await fs7__default.promises.writeFile(filePath, newContent, "utf-8");
+      await fs8__default.promises.writeFile(filePath, newContent, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2616,17 +2711,17 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
 }
 async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs7__default.existsSync(agentsDir)) {
+  if (!fs8__default.existsSync(agentsDir)) {
     return updatedFiles;
   }
-  const files = fs7__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs8__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path7__default.join(agentsDir, file);
-    let content = await fs7__default.promises.readFile(filePath, "utf-8");
+    const filePath = path8__default.join(agentsDir, file);
+    let content = await fs8__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 fs7__default.promises.writeFile(filePath, content, "utf-8");
+      await fs8__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -2753,16 +2848,16 @@ function parseThreadEndpointRouteKey(input) {
   };
 }
 function scanThreadEndpointFiles(dir, options = {}) {
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return [];
   }
   const extensions = options.extensions ?? [".ts"];
   const routes = [];
   const scan = (currentDir, relativeDir = "") => {
-    const entries = fs7__default.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const filePath = path7__default.join(currentDir, entry.name);
-      const relativePath = relativeDir ? path7__default.posix.join(relativeDir, entry.name) : entry.name;
+      const filePath = path8__default.join(currentDir, entry.name);
+      const relativePath = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         scan(filePath, relativePath);
         continue;
@@ -2796,7 +2891,7 @@ function scanApiDirectory(dir) {
   try {
     return scanThreadEndpointFiles(dir, {
       extensions: [".ts"],
-      importPathForFile: (filePath) => "./" + path7__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
+      importPathForFile: (filePath) => "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
     }).map(({ method, route, importPath }) => ({
       method,
       route,
@@ -2808,26 +2903,26 @@ function scanApiDirectory(dir) {
   }
 }
 function discoverPackedPackageDirectories(packedDir) {
-  if (!fs7__default.existsSync(packedDir)) {
+  if (!fs8__default.existsSync(packedDir)) {
     return [];
   }
   const packageDirs = [];
-  const entries = fs7__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  const entries = fs8__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const entry of entries) {
-    const fullPath = path7__default.join(packedDir, entry.name);
-    const packageJsonPath = path7__default.join(fullPath, "package.json");
-    if (fs7__default.existsSync(packageJsonPath)) {
+    const fullPath = path8__default.join(packedDir, entry.name);
+    const packageJsonPath = path8__default.join(fullPath, "package.json");
+    if (fs8__default.existsSync(packageJsonPath)) {
       packageDirs.push(fullPath);
       continue;
     }
     if (!entry.name.startsWith("@")) {
       continue;
     }
-    const scopedEntries = fs7__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
+    const scopedEntries = fs8__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
     for (const scopedEntry of scopedEntries) {
-      const scopedPackagePath = path7__default.join(fullPath, scopedEntry.name);
-      const scopedPackageJson = path7__default.join(scopedPackagePath, "package.json");
-      if (fs7__default.existsSync(scopedPackageJson)) {
+      const scopedPackagePath = path8__default.join(fullPath, scopedEntry.name);
+      const scopedPackageJson = path8__default.join(scopedPackagePath, "package.json");
+      if (fs8__default.existsSync(scopedPackageJson)) {
         packageDirs.push(scopedPackagePath);
       }
     }
@@ -2835,26 +2930,26 @@ function discoverPackedPackageDirectories(packedDir) {
   return packageDirs;
 }
 function scanPackedDistDirectory(packagePath, outputDir, subDir) {
-  const fullPath = path7__default.join(packagePath, outputDir, subDir);
-  if (!fs7__default.existsSync(fullPath)) {
+  const fullPath = path8__default.join(packagePath, outputDir, subDir);
+  if (!fs8__default.existsSync(fullPath)) {
     return [];
   }
-  return fs7__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
+  return fs8__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
     name: fileName.replace(/\.(js|ts)$/, ""),
-    path: path7__default.join(fullPath, fileName).replace(/\\/g, "/")
+    path: path8__default.join(fullPath, fileName).replace(/\\/g, "/")
   }));
 }
 function scanPackedThreadEndpoints(packagePath, outputDir) {
-  const rootDir = path7__default.join(packagePath, outputDir, "thread-endpoints");
-  if (!fs7__default.existsSync(rootDir)) {
+  const rootDir = path8__default.join(packagePath, outputDir, "thread-endpoints");
+  if (!fs8__default.existsSync(rootDir)) {
     return [];
   }
   const endpoints = [];
   const scan = (dir, relativeDir = "") => {
-    const entries = fs7__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const nextRelative = relativeDir ? path7__default.posix.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = path7__default.join(dir, entry.name);
+      const nextRelative = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path8__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         scan(absolutePath, nextRelative);
         continue;
@@ -2884,7 +2979,7 @@ function isSnakeCase(str) {
 }
 function validateToolFile(filePath, fileName) {
   try {
-    const content = fs7__default.readFileSync(filePath, "utf-8");
+    const content = fs8__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()`;
@@ -2896,15 +2991,15 @@ function validateToolFile(filePath, fileName) {
 }
 async function scanToolsDirectory(dir) {
   const tools = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return tools;
   }
-  const entries = await fs7__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs8__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 = path7__default.join(dir, entry.name);
-      const importPath = "./" + path7__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      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) {
@@ -2931,18 +3026,18 @@ async function scanToolsDirectory(dir) {
 }
 async function scanHooksDirectory(dir) {
   const hooks = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return hooks;
   }
-  const entries = await fs7__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs8__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 = path7__default.join(dir, entry.name);
-      const importPath = "./" + path7__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path8__default.join(dir, entry.name);
+      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/id:\s*['"]([^'"]+)['"]/);
         const hookMatch = content.match(/hook:\s*['"]([^'"]+)['"]/);
         if (idMatch && hookMatch) {
@@ -2965,16 +3060,16 @@ async function scanHooksDirectory(dir) {
 }
 async function scanConfigDirectory(dir, definePattern) {
   const items = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return items;
   }
-  const entries = await fs7__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const filePath = path7__default.join(dir, entry.name);
-      const importPath = "./" + path7__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path8__default.join(dir, entry.name);
+      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs7__default.readFileSync(filePath, "utf-8");
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         const hasDefaultExport = definePattern.test(content);
         if (!hasDefaultExport) {
           items.push({
@@ -3016,20 +3111,20 @@ async function scanAgentsDirectory(dir) {
 }
 async function scanEffectsDirectory(dir) {
   const effects = [];
-  if (!fs7__default.existsSync(dir)) {
+  if (!fs8__default.existsSync(dir)) {
     return effects;
   }
-  const entries = await fs7__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs8__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 = path7__default.join(dir, entry.name);
-      const importPath = "./" + path7__default.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 = fs7__default.readFileSync(filePath, "utf-8");
+        const content = fs8__default.readFileSync(filePath, "utf-8");
         if (!content.includes("defineEffect")) {
           continue;
         }
@@ -3516,7 +3611,7 @@ var MetadataService = class {
    * @param agentsDir - Path to the agents/ directory
    */
   constructor(agentsDir) {
-    this.metadataDir = path7.join(agentsDir, ".standardagent");
+    this.metadataDir = path8.join(agentsDir, ".standardagent");
   }
   /**
    * Read metadata for an agent.
@@ -3526,11 +3621,11 @@ var MetadataService = class {
    */
   async read(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (!fs7.existsSync(filePath)) {
+    if (!fs8.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = fs7.readFileSync(filePath, "utf-8");
+      const content = fs8.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -3543,11 +3638,11 @@ var MetadataService = class {
    * @param metadata - Metadata to write
    */
   async write(agentName, metadata) {
-    if (!fs7.existsSync(this.metadataDir)) {
-      fs7.mkdirSync(this.metadataDir, { recursive: true });
+    if (!fs8.existsSync(this.metadataDir)) {
+      fs8.mkdirSync(this.metadataDir, { recursive: true });
     }
     const filePath = this.getMetadataPath(agentName);
-    fs7.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+    fs8.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Delete metadata for an agent.
@@ -3556,8 +3651,8 @@ var MetadataService = class {
    */
   async delete(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (fs7.existsSync(filePath)) {
-      fs7.unlinkSync(filePath);
+    if (fs8.existsSync(filePath)) {
+      fs8.unlinkSync(filePath);
     }
   }
   /**
@@ -3638,7 +3733,7 @@ var MetadataService = class {
    * Get the file path for an agent's metadata.
    */
   getMetadataPath(agentName) {
-    return path7.join(this.metadataDir, `${agentName}.json`);
+    return path8.join(this.metadataDir, `${agentName}.json`);
   }
 };
 var _ts;
@@ -4010,9 +4105,9 @@ var PackingService = class {
    * @returns Version specifier (e.g., '^1.2.3') or '*' if not found
    */
   resolvePackageVersion(pkgName, rootDir) {
-    const pkgJsonPath = path7.join(rootDir, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path8.join(rootDir, "node_modules", pkgName, "package.json");
     try {
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       return `^${pkgJson.version}`;
     } catch {
       return "*";
@@ -4029,7 +4124,7 @@ var PackingService = class {
    * @returns Analysis result with all discovered constituents
    */
   async analyzeAgent(agentName, rootDir) {
-    const agentsDir = path7.join(rootDir, "agents");
+    const agentsDir = path8.join(rootDir, "agents");
     const analysis = {
       agent: agentName,
       primaryPrompt: "",
@@ -4053,7 +4148,7 @@ var PackingService = class {
       warnings: [],
       errors: []
     };
-    const agentFilePath = await this.findFile(path7.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.errors.push(`Agent file not found: ${agentName}`);
       return analysis;
@@ -4064,7 +4159,7 @@ var PackingService = class {
       discoveredVia: "static",
       sharedWith: []
     });
-    const agentSource = fs7.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
@@ -4089,13 +4184,13 @@ var PackingService = class {
    * @returns Object with generatedReadme and agentDescription
    */
   async generateReadmeForAnalysis(analysis, rootDir) {
-    const agentsDir = path7.join(rootDir, "agents");
+    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 = fs7.readFileSync(agentItem.filePath, "utf-8");
+        const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
         agentDescription = await extractAgentDescription(agentSource) || void 0;
       } catch {
       }
@@ -4119,7 +4214,7 @@ var PackingService = class {
    * include all endpoint modules discovered under agents/api.
    */
   async analyzeThreadEndpoints(agentsDir, analysis) {
-    const apiDir = path7.join(agentsDir, "api");
+    const apiDir = path8.join(agentsDir, "api");
     const endpoints = this.scanThreadEndpointFiles(apiDir);
     for (const endpoint of endpoints) {
       if (analysis.constituents.threadEndpoints.some((item) => item.name === endpoint.name)) {
@@ -4141,15 +4236,15 @@ var PackingService = class {
    * - `admin/users/[userId]/sync.post`
    */
   scanThreadEndpointFiles(apiDir, relativeDir = "") {
-    if (!fs7.existsSync(apiDir)) {
+    if (!fs8.existsSync(apiDir)) {
       return [];
     }
     const endpoints = [];
-    const currentDir = relativeDir ? path7.join(apiDir, relativeDir) : apiDir;
-    if (!fs7.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path8.join(apiDir, relativeDir) : apiDir;
+    if (!fs8.existsSync(currentDir)) {
       return endpoints;
     }
-    const entries = fs7.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return endpoints;
     }
@@ -4157,8 +4252,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path7.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path7.join(apiDir, entryRelative);
+      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path8.join(apiDir, entryRelative);
       if (isDirectory) {
         endpoints.push(...this.scanThreadEndpointFiles(apiDir, entryRelative));
         continue;
@@ -4185,7 +4280,7 @@ var PackingService = class {
    * include all effect modules discovered under agents/effects.
    */
   async analyzeEffects(agentsDir, analysis) {
-    const effectsDir = path7.join(agentsDir, "effects");
+    const effectsDir = path8.join(agentsDir, "effects");
     const effects = this.scanEffectFiles(effectsDir);
     for (const effect of effects) {
       if (analysis.constituents.effects.some((item) => item.name === effect.name)) {
@@ -4207,15 +4302,15 @@ var PackingService = class {
    * - `notifications/digest`
    */
   scanEffectFiles(effectsDir, relativeDir = "") {
-    if (!fs7.existsSync(effectsDir)) {
+    if (!fs8.existsSync(effectsDir)) {
       return [];
     }
     const effects = [];
-    const currentDir = relativeDir ? path7.join(effectsDir, relativeDir) : effectsDir;
-    if (!fs7.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path8.join(effectsDir, relativeDir) : effectsDir;
+    if (!fs8.existsSync(currentDir)) {
       return effects;
     }
-    const entries = fs7.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return effects;
     }
@@ -4223,8 +4318,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path7.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path7.join(effectsDir, entryRelative);
+      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path8.join(effectsDir, entryRelative);
       if (isDirectory) {
         effects.push(...this.scanEffectFiles(effectsDir, entryRelative));
         continue;
@@ -4248,7 +4343,7 @@ var PackingService = class {
    * Recursively analyze a prompt and its dependencies.
    */
   async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
-    const promptFilePath = await this.findFile(path7.join(agentsDir, "prompts"), promptName);
+    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
     if (!promptFilePath) {
       analysis.warnings.push(`Prompt file not found: ${promptName}`);
       return;
@@ -4267,7 +4362,7 @@ var PackingService = class {
       return;
     }
     visited.add(`prompt:${promptName}`);
-    const promptSource = fs7.readFileSync(promptFilePath, "utf-8");
+    const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -4293,17 +4388,17 @@ var PackingService = class {
    */
   async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
     const thisKey = `tool:${toolName}`;
-    const promptFilePath = await this.findFile(path7.join(agentsDir, "prompts"), toolName);
+    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), toolName);
     if (promptFilePath) {
       await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const agentFilePath = await this.findFile(path7.join(agentsDir, "agents"), toolName);
+    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), toolName);
     if (agentFilePath) {
       await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const toolFilePath = await this.findFile(path7.join(agentsDir, "tools"), toolName);
+    const toolFilePath = await this.findFile(path8.join(agentsDir, "tools"), toolName);
     if (!toolFilePath) {
       analysis.warnings.push(`Tool file not found: ${toolName}`);
       return;
@@ -4321,7 +4416,7 @@ var PackingService = class {
       return;
     }
     visited.add(`tool:${toolName}`);
-    const toolSource = fs7.readFileSync(toolFilePath, "utf-8");
+    const toolSource = fs8.readFileSync(toolFilePath, "utf-8");
     const { uses } = await extractToolUses(toolSource);
     for (const usedItem of uses) {
       await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
@@ -4331,7 +4426,7 @@ var PackingService = class {
    * Analyze a nested agent (used as a handoff target).
    */
   async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
-    const agentFilePath = await this.findFile(path7.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.warnings.push(`Agent file not found: ${agentName}`);
       return;
@@ -4350,7 +4445,7 @@ var PackingService = class {
       return;
     }
     visited.add(`agent:${agentName}`);
-    const agentSource = fs7.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
@@ -4363,7 +4458,7 @@ var PackingService = class {
    * Analyze a model and its fallbacks.
    */
   async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
-    const modelFilePath = await this.findFile(path7.join(agentsDir, "models"), modelName);
+    const modelFilePath = await this.findFile(path8.join(agentsDir, "models"), modelName);
     if (!modelFilePath) {
       analysis.warnings.push(`Model file not found: ${modelName}`);
       return;
@@ -4382,7 +4477,7 @@ var PackingService = class {
       return;
     }
     visited.add(`model:${modelName}`);
-    const modelSource = fs7.readFileSync(modelFilePath, "utf-8");
+    const modelSource = fs8.readFileSync(modelFilePath, "utf-8");
     const fallbacks = await extractModelFallbacks(modelSource);
     for (const fallbackName of fallbacks) {
       await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
@@ -4392,13 +4487,13 @@ var PackingService = class {
    * Check which items are shared with other agents.
    */
   async checkSharedItems(agentsDir, analysis) {
-    const agentsPath = path7.join(agentsDir, "agents");
-    if (!fs7.existsSync(agentsPath)) return;
-    const agentFiles = fs7.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    const agentsPath = path8.join(agentsDir, "agents");
+    if (!fs8.existsSync(agentsPath)) return;
+    const agentFiles = fs8.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, path7.dirname(agentsDir));
+      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);
@@ -4430,19 +4525,19 @@ var PackingService = class {
    */
   async analyzeAgentLight(agentName, rootDir) {
     const result = { prompts: [], tools: [], models: [] };
-    const agentsDir = path7.join(rootDir, "agents");
+    const agentsDir = path8.join(rootDir, "agents");
     const visited = /* @__PURE__ */ new Set();
-    const agentFilePath = await this.findFile(path7.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) return result;
-    const agentSource = fs7.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     const analyzePromptLight = async (promptName) => {
       if (visited.has(promptName)) return;
       visited.add(promptName);
       result.prompts.push(promptName);
-      const promptFilePath = await this.findFile(path7.join(agentsDir, "prompts"), promptName);
+      const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
       if (!promptFilePath) return;
-      const promptSource = fs7.readFileSync(promptFilePath, "utf-8");
+      const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
       const modelName = await extractPromptModel(promptSource);
       if (modelName && !result.models.includes(modelName)) {
         result.models.push(modelName);
@@ -4515,14 +4610,14 @@ var PackingService = class {
         return result;
       }
       result.warnings = analysis.warnings;
-      const pkgOutputDir = path7.join(outputDir, packageId);
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "agents"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "tools"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "models"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "effects"), { recursive: true });
-      fs7.mkdirSync(path7.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
+      const pkgOutputDir = path8.join(outputDir, packageId);
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "effects"), { recursive: true });
+      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
       const seenItems = /* @__PURE__ */ new Set();
       const allItems = [];
       for (const a of analysis.constituents.agents) {
@@ -4576,13 +4671,13 @@ var PackingService = class {
       }
       const externalDeps = /* @__PURE__ */ new Map();
       for (const item of allItems) {
-        const outputPath = path7.join(
+        const outputPath = path8.join(
           pkgOutputDir,
           "dist",
           this.getTypeDir(item.type),
           `${item.name}.js`
         );
-        fs7.mkdirSync(path7.dirname(outputPath), { recursive: true });
+        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
         const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
         for (const [depName, depVersion] of deps) {
           if (!externalDeps.has(depName)) {
@@ -4592,12 +4687,12 @@ var PackingService = class {
         result.filesCreated.push(outputPath);
       }
       const indexJs = this.generateReExportIndex(analysis, meta);
-      const indexJsPath = path7.join(pkgOutputDir, "dist", "index.js");
-      fs7.writeFileSync(indexJsPath, indexJs);
+      const indexJsPath = path8.join(pkgOutputDir, "dist", "index.js");
+      fs8.writeFileSync(indexJsPath, indexJs);
       result.filesCreated.push(indexJsPath);
       const indexDts = this.generateIndexDts(analysis);
-      const indexDtsPath = path7.join(pkgOutputDir, "dist", "index.d.ts");
-      fs7.writeFileSync(indexDtsPath, indexDts);
+      const indexDtsPath = path8.join(pkgOutputDir, "dist", "index.d.ts");
+      fs8.writeFileSync(indexDtsPath, indexDts);
       result.filesCreated.push(indexDtsPath);
       const pkgJson = this.generatePackageJson(
         finalPackageName,
@@ -4610,13 +4705,13 @@ var PackingService = class {
         license,
         licenseOwner
       );
-      const pkgJsonPath = path7.join(pkgOutputDir, "package.json");
-      fs7.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      const pkgJsonPath = path8.join(pkgOutputDir, "package.json");
+      fs8.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
       result.filesCreated.push(pkgJsonPath);
       if (license) {
         const licenseContent = this.generateLicenseFile(license, licenseOwner);
-        const licensePath = path7.join(pkgOutputDir, "LICENSE");
-        fs7.writeFileSync(licensePath, licenseContent);
+        const licensePath = path8.join(pkgOutputDir, "LICENSE");
+        fs8.writeFileSync(licensePath, licenseContent);
         result.filesCreated.push(licensePath);
       }
       let readmeContent = readme;
@@ -4624,7 +4719,7 @@ var PackingService = class {
         const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
         let agentDescription;
         if (agentItem?.filePath) {
-          const agentSource = fs7.readFileSync(agentItem.filePath, "utf-8");
+          const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
           agentDescription = await extractAgentDescription(agentSource) || void 0;
         }
         readmeContent = this.generateReadme(
@@ -4635,21 +4730,21 @@ var PackingService = class {
           agentDescription
         );
       }
-      const readmePath = path7.join(pkgOutputDir, "README.md");
-      fs7.writeFileSync(readmePath, readmeContent);
+      const readmePath = path8.join(pkgOutputDir, "README.md");
+      fs8.writeFileSync(readmePath, readmeContent);
       result.filesCreated.push(readmePath);
       if (removeOriginals || itemSelections) {
         result.filesRemoved = [];
         for (const item of allItems) {
           const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
           const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0 && item.type !== "thread-endpoint" && item.type !== "effect";
-          if (shouldRemove && fs7.existsSync(item.filePath)) {
-            fs7.unlinkSync(item.filePath);
+          if (shouldRemove && fs8.existsSync(item.filePath)) {
+            fs8.unlinkSync(item.filePath);
             result.filesRemoved.push(item.filePath);
           }
         }
       }
-      const agentsDir = path7.join(rootDir, "agents");
+      const agentsDir = path8.join(rootDir, "agents");
       const metadataService = new MetadataService(agentsDir);
       const metadata = {
         packageName: finalPackageName,
@@ -4683,7 +4778,7 @@ var PackingService = class {
     const commonjs = (await import('@rollup/plugin-commonjs')).default;
     const esbuild = (await import('rollup-plugin-esbuild')).default;
     const externalDeps = /* @__PURE__ */ new Map();
-    const agentsDir = path7.join(rootDir, "agents");
+    const agentsDir = path8.join(rootDir, "agents");
     const resolveVersion = this.resolvePackageVersion.bind(this);
     const trackExternalsPlugin = {
       name: "track-externals",
@@ -4692,14 +4787,14 @@ var PackingService = class {
           return null;
         }
         if (source.startsWith("./") || source.startsWith("../")) {
-          const resolved = path7.resolve(path7.dirname(importer), source);
+          const resolved = path8.resolve(path8.dirname(importer), source);
           let tsResolved = resolved;
           if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-            if (fs7.existsSync(`${resolved}.ts`)) {
+            if (fs8.existsSync(`${resolved}.ts`)) {
               tsResolved = `${resolved}.ts`;
-            } else if (fs7.existsSync(`${resolved}.js`)) {
+            } else if (fs8.existsSync(`${resolved}.js`)) {
               tsResolved = `${resolved}.js`;
-            } else if (fs7.existsSync(`${resolved}/index.ts`)) {
+            } else if (fs8.existsSync(`${resolved}/index.ts`)) {
               tsResolved = `${resolved}/index.ts`;
             }
           }
@@ -4748,11 +4843,11 @@ var PackingService = class {
         exports: "named"
       });
       const bundledCode = output[0].code;
-      const header = `// Bundled from: ${path7.relative(rootDir, inputPath)}
+      const header = `// Bundled from: ${path8.relative(rootDir, inputPath)}
 // Local dependencies have been inlined
 
 `;
-      fs7.writeFileSync(outputPath, header + bundledCode);
+      fs8.writeFileSync(outputPath, header + bundledCode);
       await bundle.close();
     } catch (error) {
       await bundle.close();
@@ -5177,30 +5272,30 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Package info or null if not found
    */
   getPackedInfo(packageId, rootDir) {
-    const packedDir = path7.join(rootDir, "agents", "packed");
-    let packageDir = path7.join(packedDir, packageId);
-    if (!fs7.existsSync(packageDir)) {
-      if (!fs7.existsSync(packedDir)) {
+    const packedDir = path8.join(rootDir, "agents", "packed");
+    let packageDir = path8.join(packedDir, packageId);
+    if (!fs8.existsSync(packageDir)) {
+      if (!fs8.existsSync(packedDir)) {
         return null;
       }
-      const dirs = fs7.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = fs8.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 = path7.join(packedDir, matchingDir);
+      packageDir = path8.join(packedDir, matchingDir);
     }
-    const pkgJsonPath = path7.join(packageDir, "package.json");
-    if (!fs7.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path8.join(packageDir, "package.json");
+    if (!fs8.existsSync(pkgJsonPath)) {
       return null;
     }
-    const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
     let readme;
-    const readmePath = path7.join(packageDir, "README.md");
-    if (fs7.existsSync(readmePath)) {
-      readme = fs7.readFileSync(readmePath, "utf-8");
+    const readmePath = path8.join(packageDir, "README.md");
+    if (fs8.existsSync(readmePath)) {
+      readme = fs8.readFileSync(readmePath, "utf-8");
     }
     return {
       packageName: pkgJson.name,
@@ -5218,11 +5313,11 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Array of package directory names
    */
   listPackedPackages(rootDir) {
-    const packedDir = path7.join(rootDir, "agents", "packed");
-    if (!fs7.existsSync(packedDir)) {
+    const packedDir = path8.join(rootDir, "agents", "packed");
+    if (!fs8.existsSync(packedDir)) {
       return [];
     }
-    return fs7.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs8.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   /**
    * Generate README.md content for a packed agent.
@@ -5269,17 +5364,17 @@ ${license || "See LICENSE file"}
    * Find a file by name in a directory.
    */
   async findFile(dir, name) {
-    if (!fs7.existsSync(dir)) {
+    if (!fs8.existsSync(dir)) {
       return null;
     }
-    const exactPath = path7.join(dir, `${name}.ts`);
-    if (fs7.existsSync(exactPath)) {
+    const exactPath = path8.join(dir, `${name}.ts`);
+    if (fs8.existsSync(exactPath)) {
       return exactPath;
     }
-    const files = fs7.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".ts"));
     for (const file of files) {
-      const filePath = path7.join(dir, file);
-      const source = fs7.readFileSync(filePath, "utf-8");
+      const filePath = path8.join(dir, file);
+      const source = fs8.readFileSync(filePath, "utf-8");
       const extractedName = await extractDefinitionName(source);
       if (extractedName === name) {
         return filePath;
@@ -5291,15 +5386,15 @@ ${license || "See LICENSE file"}
    * List all agents in the workspace.
    */
   async listAgents(rootDir) {
-    const agentsDir = path7.join(rootDir, "agents", "agents");
-    if (!fs7.existsSync(agentsDir)) {
+    const agentsDir = path8.join(rootDir, "agents", "agents");
+    if (!fs8.existsSync(agentsDir)) {
       return [];
     }
-    const files = fs7.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const files = fs8.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
     const agents = [];
     for (const file of files) {
-      const filePath = path7.join(agentsDir, file);
-      const source = fs7.readFileSync(filePath, "utf-8");
+      const filePath = path8.join(agentsDir, file);
+      const source = fs8.readFileSync(filePath, "utf-8");
       const name = await extractDefinitionName(source);
       if (name) {
         agents.push(name);
@@ -5315,7 +5410,7 @@ var PackageDiscoveryService = class {
   constructor(config) {
     this.config = {
       rootDir: config.rootDir,
-      packedDir: config.packedDir ?? path7.join(config.rootDir, "agents", "packed"),
+      packedDir: config.packedDir ?? path8.join(config.rootDir, "agents", "packed"),
       scanNpm: config.scanNpm ?? true,
       scanLocal: config.scanLocal ?? true
     };
@@ -5348,19 +5443,19 @@ var PackageDiscoveryService = class {
    */
   async discoverNpmPackages() {
     const packages = [];
-    const nodeModulesDir = path7.join(this.config.rootDir, "node_modules");
-    if (!fs7.existsSync(nodeModulesDir)) {
+    const nodeModulesDir = path8.join(this.config.rootDir, "node_modules");
+    if (!fs8.existsSync(nodeModulesDir)) {
       return packages;
     }
     const rootEntries = await this.scanDirectory(nodeModulesDir);
     for (const entry of rootEntries) {
       if (entry.startsWith(".")) continue;
       if (entry.startsWith("@")) {
-        const scopeDir = path7.join(nodeModulesDir, entry);
+        const scopeDir = path8.join(nodeModulesDir, entry);
         const scopeEntries = await this.scanDirectory(scopeDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const pkgDir = path7.join(scopeDir, scopedPkg);
+          const pkgDir = path8.join(scopeDir, scopedPkg);
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkNpmPackage(pkgDir, fullName);
           if (pkg) {
@@ -5368,7 +5463,7 @@ var PackageDiscoveryService = class {
           }
         }
       } else {
-        const pkgDir = path7.join(nodeModulesDir, entry);
+        const pkgDir = path8.join(nodeModulesDir, entry);
         const pkg = await this.checkNpmPackage(pkgDir, entry);
         if (pkg) {
           packages.push(pkg);
@@ -5384,12 +5479,12 @@ var PackageDiscoveryService = class {
    * which must contain `entryAgents` array.
    */
   async checkNpmPackage(pkgDir, pkgName) {
-    const pkgJsonPath = path7.join(pkgDir, "package.json");
-    if (!fs7.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path8.join(pkgDir, "package.json");
+    if (!fs8.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       const isStandardAgent = (
         // Has "standardagent" keyword
         pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
@@ -5426,21 +5521,21 @@ var PackageDiscoveryService = class {
    */
   async discoverLocalPackages() {
     const packages = [];
-    if (!fs7.existsSync(this.config.packedDir)) {
+    if (!fs8.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 = path7.join(this.config.packedDir, entry);
-      const stat = fs7.statSync(pkgDir);
+      const pkgDir = path8.join(this.config.packedDir, entry);
+      const stat = fs8.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 = path7.join(pkgDir, scopedPkg);
-          const scopedStat = fs7.statSync(scopedPkgDir);
+          const scopedPkgDir = path8.join(pkgDir, scopedPkg);
+          const scopedStat = fs8.statSync(scopedPkgDir);
           if (!scopedStat.isDirectory()) continue;
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
@@ -5463,12 +5558,12 @@ var PackageDiscoveryService = class {
    * Detection is based on the `standardagent` field in package.json.
    */
   async checkLocalPackage(pkgDir, dirName) {
-    const pkgJsonPath = path7.join(pkgDir, "package.json");
-    if (!fs7.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path8.join(pkgDir, "package.json");
+    if (!fs8.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
@@ -5493,10 +5588,10 @@ var PackageDiscoveryService = class {
    * Scan a directory and return entry names.
    */
   async scanDirectory(dir) {
-    if (!fs7.existsSync(dir)) {
+    if (!fs8.existsSync(dir)) {
       return [];
     }
-    const entries = fs7.readdirSync(dir);
+    const entries = fs8.readdirSync(dir);
     return entries;
   }
   /**
@@ -5589,29 +5684,29 @@ var UnpackingService = class {
       }
       analysis.version = pkg.version;
       analysis.source = pkg.source;
-      const indexPath = path7.join(pkg.path, "dist", "index.js");
-      if (!fs7.existsSync(indexPath)) {
+      const indexPath = path8.join(pkg.path, "dist", "index.js");
+      if (!fs8.existsSync(indexPath)) {
         analysis.errors.push(`Package index not found: ${indexPath}`);
         return analysis;
       }
-      const indexContent = fs7.readFileSync(indexPath, "utf-8");
+      const indexContent = fs8.readFileSync(indexPath, "utf-8");
       const registryItems = await this.parseIndexExports(indexContent);
       const availableItems = /* @__PURE__ */ new Map();
       for (const item of registryItems) {
         availableItems.set(`${item.type}:${item.name}`, item);
       }
-      const agentsDir = path7.join(rootDir, "agents");
+      const agentsDir = path8.join(rootDir, "agents");
       const itemsWithRelations = [];
       for (const item of registryItems) {
-        const targetPath = path7.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
-        const sourcePath = path7.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const targetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
         const existsGlobally = this.fileExists(targetPath);
-        const sourceExists = fs7.existsSync(sourcePath);
+        const sourceExists = fs8.existsSync(sourcePath);
         if (!sourceExists) {
           analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
           continue;
         }
-        const bundledCode = fs7.readFileSync(sourcePath, "utf-8");
+        const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
         const children = await this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
         itemsWithRelations.push({
           name: item.name,
@@ -5621,10 +5716,10 @@ var UnpackingService = class {
           action: existsGlobally ? "skip" : "generate"
         });
         for (const child of children) {
-          const childTargetPath = path7.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
-          const childSourcePath = path7.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childTargetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
           const childExists = this.fileExists(childTargetPath);
-          const childSourceExists = fs7.existsSync(childSourcePath);
+          const childSourceExists = fs8.existsSync(childSourcePath);
           if (!childSourceExists) {
             continue;
           }
@@ -5727,8 +5822,8 @@ var UnpackingService = class {
         return result;
       }
       const itemsToProcess = this.applySelections(analysis.items, itemSelections);
-      const pkgJsonPath = path7.join(pkg.path, "package.json");
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJsonPath = path8.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       let author = "";
       if (typeof pkgJson.author === "string") {
         author = pkgJson.author;
@@ -5753,17 +5848,17 @@ var UnpackingService = class {
           continue;
         }
         try {
-          const sourcePath = path7.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
-          const bundledCode = fs7.readFileSync(sourcePath, "utf-8");
+          const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
           let tsCode = await transformBundledJs(bundledCode);
           if (item.type === "agent") {
             tsCode = await injectAgentMetadata(tsCode, agentMetadata);
           }
-          const dir = path7.dirname(item.targetPath);
-          if (!fs7.existsSync(dir)) {
-            fs7.mkdirSync(dir, { recursive: true });
+          const dir = path8.dirname(item.targetPath);
+          if (!fs8.existsSync(dir)) {
+            fs8.mkdirSync(dir, { recursive: true });
           }
-          fs7.writeFileSync(item.targetPath, tsCode);
+          fs8.writeFileSync(item.targetPath, tsCode);
           result.filesGenerated.push(item.targetPath);
         } catch (error) {
           result.warnings.push(
@@ -5852,14 +5947,14 @@ var UnpackingService = class {
    */
   async resolvePackage(pkgIdentifier, rootDir) {
     if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
-      const absolutePath = path7.isAbsolute(pkgIdentifier) ? pkgIdentifier : path7.join(rootDir, pkgIdentifier);
-      const pkgJsonPath2 = path7.join(absolutePath, "package.json");
-      if (fs7.existsSync(pkgJsonPath2)) {
+      const absolutePath = path8.isAbsolute(pkgIdentifier) ? pkgIdentifier : path8.join(rootDir, pkgIdentifier);
+      const pkgJsonPath2 = path8.join(absolutePath, "package.json");
+      if (fs8.existsSync(pkgJsonPath2)) {
         try {
-          const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath2, "utf-8"));
+          const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath2, "utf-8"));
           if (pkgJson.standardagent?.entryAgents) {
             return {
-              packageId: pkgJson.name || path7.basename(absolutePath),
+              packageId: pkgJson.name || path8.basename(absolutePath),
               version: pkgJson.version || "0.0.0",
               source: "local",
               path: absolutePath,
@@ -5871,11 +5966,11 @@ var UnpackingService = class {
       }
       return null;
     }
-    const packedDir = path7.join(rootDir, "agents", "packed", pkgIdentifier);
-    const pkgJsonPath = path7.join(packedDir, "package.json");
-    if (fs7.existsSync(pkgJsonPath)) {
+    const packedDir = path8.join(rootDir, "agents", "packed", pkgIdentifier);
+    const pkgJsonPath = path8.join(packedDir, "package.json");
+    if (fs8.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.standardagent?.entryAgents) {
           return {
             packageId: pkgJson.name || pkgIdentifier,
@@ -5916,18 +6011,18 @@ var UnpackingService = class {
    * Check if a file exists.
    */
   fileExists(filePath) {
-    if (fs7.existsSync(filePath)) {
+    if (fs8.existsSync(filePath)) {
       return true;
     }
     const withoutExt = filePath.replace(/\.(ts|js)$/, "");
-    return fs7.existsSync(`${withoutExt}.ts`) || fs7.existsSync(`${withoutExt}.js`);
+    return fs8.existsSync(`${withoutExt}.ts`) || fs8.existsSync(`${withoutExt}.js`);
   }
   /**
    * Recursively delete a directory.
    */
   deleteDirectory(dirPath) {
-    if (fs7.existsSync(dirPath)) {
-      fs7.rmSync(dirPath, { recursive: true, force: true });
+    if (fs8.existsSync(dirPath)) {
+      fs8.rmSync(dirPath, { recursive: true, force: true });
     }
   }
   /**
@@ -6003,8 +6098,8 @@ var NpmPublishService = class {
         error: "Registry URL must use HTTPS"
       };
     }
-    const pkgJsonPath = path7.join(packageDir, "package.json");
-    if (!fs7.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path8.join(packageDir, "package.json");
+    if (!fs8.existsSync(pkgJsonPath)) {
       return {
         success: false,
         output: "",
@@ -6014,7 +6109,7 @@ var NpmPublishService = class {
     let packageName;
     let version;
     try {
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       packageName = pkgJson.name;
       version = pkgJson.version;
     } catch (e) {
@@ -6024,13 +6119,13 @@ var NpmPublishService = class {
         error: `Failed to read package.json: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-    const npmrcPath = path7.join(packageDir, ".npmrc");
+    const npmrcPath = path8.join(packageDir, ".npmrc");
     const registryHost = new URL(registry).host;
     const npmrcContent = `//${registryHost}/:_authToken=${token}
 registry=${registry}
 `;
     try {
-      fs7.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
+      fs8.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
       const args = ["publish"];
       if (dryRun) {
         args.push("--dry-run");
@@ -6062,8 +6157,8 @@ registry=${registry}
       };
     } finally {
       try {
-        if (fs7.existsSync(npmrcPath)) {
-          fs7.unlinkSync(npmrcPath);
+        if (fs8.existsSync(npmrcPath)) {
+          fs8.unlinkSync(npmrcPath);
         }
       } catch {
       }
@@ -6156,7 +6251,7 @@ async function handlePackingApiRequest(context) {
       const body = await parseRequestBody(req);
       const packingService = new PackingService();
       const rootDir = process.cwd();
-      const outputDir = path7__default.join(rootDir, "agents", "packed");
+      const outputDir = path8__default.join(rootDir, "agents", "packed");
       const result = await packingService.pack({
         agentName,
         rootDir,
@@ -6209,8 +6304,8 @@ async function handlePackingApiRequest(context) {
         res.end(JSON.stringify({ error: "Cannot delete npm packages. Use npm uninstall instead." }));
         return true;
       }
-      const fs17 = await import('fs');
-      fs17.rmSync(pkg.path, { recursive: true, force: true });
+      const fs18 = await import('fs');
+      fs18.rmSync(pkg.path, { recursive: true, force: true });
       await reloadAllAgentModules(context);
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
@@ -6238,8 +6333,8 @@ async function handlePackingApiRequest(context) {
         return true;
       }
       const { spawn } = await import('child_process');
-      const parentDir = path7__default.dirname(pkg.path);
-      const dirName = path7__default.basename(pkg.path);
+      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]);
@@ -6295,16 +6390,16 @@ async function handlePackingApiRequest(context) {
       const packageId = decodeURIComponent(packPublishMatch[1]);
       const body = await parseRequestBody(req);
       const rootDir = process.cwd();
-      const packedDir = path7__default.join(rootDir, "agents", "packed");
-      let packageDir = path7__default.join(packedDir, packageId);
-      if (!fs7__default.existsSync(packageDir)) {
-        if (!fs7__default.existsSync(packedDir)) {
+      const packedDir = path8__default.join(rootDir, "agents", "packed");
+      let packageDir = path8__default.join(packedDir, packageId);
+      if (!fs8__default.existsSync(packageDir)) {
+        if (!fs8__default.existsSync(packedDir)) {
           res.statusCode = 400;
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify({ error: "No packed packages found. Pack the agent first." }));
           return true;
         }
-        const dirs = fs7__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        const dirs = fs8__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, "-")}`
         );
@@ -6316,14 +6411,14 @@ async function handlePackingApiRequest(context) {
           }));
           return true;
         }
-        packageDir = path7__default.join(packedDir, matchingDir);
+        packageDir = path8__default.join(packedDir, matchingDir);
       }
       let token = body.token || process.env.NPM_TOKEN;
       let tokenSource = body.token ? "provided" : "environment";
       if (!token) {
-        const devVarsPath = path7__default.join(rootDir, ".dev.vars");
-        if (fs7__default.existsSync(devVarsPath)) {
-          const devVars = fs7__default.readFileSync(devVarsPath, "utf-8");
+        const devVarsPath = path8__default.join(rootDir, ".dev.vars");
+        if (fs8__default.existsSync(devVarsPath)) {
+          const devVars = fs8__default.readFileSync(devVarsPath, "utf-8");
           const match = devVars.match(/^NPM_TOKEN=(.+)$/m);
           if (match) {
             token = match[1].trim();
@@ -6435,6 +6530,23 @@ async function handlePackingApiRequest(context) {
 }
 
 // src/plugin/dev-middleware.ts
+function readRawRequestBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      resolve2(chunks.length > 0 ? Buffer.concat(chunks) : void 0);
+    });
+    req.on("error", reject);
+  });
+}
+function injectUiConfigIntoHtml(htmlContent, mountPoint) {
+  const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}", devMode: true };</script>`;
+  const assetPrefix = mountPoint === "/" ? "/" : `${mountPoint}/`;
+  return htmlContent.replace(/\/agents\//g, assetPrefix).replace("</head>", `${configScript}</head>`);
+}
 function createDevMiddleware(server, context) {
   const {
     mountPoint,
@@ -6466,6 +6578,19 @@ function createDevMiddleware(server, context) {
       pathWithoutMount = "/" + pathWithoutMount;
     }
     const method = req.method?.toUpperCase();
+    const legacyMountPoint = "/agentbuilder";
+    if (mountPoint === "/" && (pathWithoutMount === legacyMountPoint || pathWithoutMount.startsWith(`${legacyMountPoint}/`))) {
+      const normalizedPath = pathWithoutMount.slice(legacyMountPoint.length) || "/";
+      if (normalizedPath.startsWith("/api/")) {
+        req.url = normalizedPath;
+        pathWithoutMount = normalizedPath;
+      } else if (method === "GET" || method === "HEAD") {
+        res.statusCode = 302;
+        res.setHeader("Location", normalizedPath);
+        res.end();
+        return;
+      }
+    }
     if (await handleConfigApiRequest({
       req,
       res,
@@ -6496,6 +6621,14 @@ function createDevMiddleware(server, context) {
     })) {
       return;
     }
+    const bootstrapCookie = resolveLocalBootstrapCookie(
+      process.cwd(),
+      pathWithoutMount,
+      req.headers.cookie
+    );
+    if (bootstrapCookie) {
+      req.headers.cookie = mergeCookieHeader(req.headers.cookie, bootstrapCookie);
+    }
     if (pathWithoutMount.startsWith("/api/")) {
       next();
       return;
@@ -6504,13 +6637,38 @@ function createDevMiddleware(server, context) {
     if (uiDevServer && !pathWithoutMount.startsWith("/api/")) {
       const targetUrl = `${uiDevServer}${pathWithoutMount}`;
       try {
-        const proxyRes = await fetch(targetUrl);
+        const proxyHeaders = new Headers();
+        for (const [key, value] of Object.entries(req.headers)) {
+          if (value === void 0) continue;
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              proxyHeaders.append(key, item);
+            }
+            continue;
+          }
+          proxyHeaders.set(key, value);
+        }
+        proxyHeaders.delete("host");
+        const proxyBody = method === "GET" || method === "HEAD" ? void 0 : await readRawRequestBody(req);
+        const proxyRes = await fetch(targetUrl, {
+          method: method || "GET",
+          headers: proxyHeaders,
+          body: proxyBody
+        });
         res.statusCode = proxyRes.status;
         proxyRes.headers.forEach((value, key) => {
-          if (!["content-encoding", "transfer-encoding"].includes(key.toLowerCase())) {
+          if (!["content-encoding", "transfer-encoding", "content-length"].includes(key.toLowerCase())) {
             res.setHeader(key, value);
           }
         });
+        const contentType = proxyRes.headers.get("content-type") || "";
+        if (contentType.includes("text/html")) {
+          const htmlBody = await proxyRes.text();
+          const injectedHtml = Buffer.from(injectUiConfigIntoHtml(htmlBody, mountPoint));
+          res.setHeader("content-length", String(injectedHtml.byteLength));
+          res.end(injectedHtml);
+          return;
+        }
         const body = await proxyRes.arrayBuffer();
         res.end(Buffer.from(body));
         return;
@@ -6521,30 +6679,27 @@ function createDevMiddleware(server, context) {
     const clientPath = mountPoint === "/" && pathWithoutMount.startsWith("/agents/") ? pathWithoutMount.slice("/agents".length) || "/" : pathWithoutMount;
     const isStaticAsset = clientPath.startsWith("/assets/") || clientPath.startsWith("/vendor.js") || clientPath.startsWith("/vue.js") || clientPath.startsWith("/monaco.js") || clientPath.startsWith("/index.js") || clientPath.startsWith("/index.css") || clientPath.match(/\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico)$/);
     {
-      const currentDir = path7__default.dirname(fileURLToPath(import.meta.url));
+      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path7__default.resolve(
+      const clientDir = path8__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
       let filePath;
       if (isStaticAsset) {
         const cleanUrl = clientPath.split("?")[0];
-        filePath = path7__default.join(clientDir, cleanUrl);
+        filePath = path8__default.join(clientDir, cleanUrl);
       } else {
-        filePath = path7__default.join(clientDir, "index.html");
+        filePath = path8__default.join(clientDir, "index.html");
       }
       try {
-        if (fs7__default.existsSync(filePath)) {
-          let content = fs7__default.readFileSync(filePath);
-          const ext = path7__default.extname(filePath).toLowerCase();
+        if (fs8__default.existsSync(filePath)) {
+          let content = fs8__default.readFileSync(filePath);
+          const ext = path8__default.extname(filePath).toLowerCase();
           if (ext === ".html") {
-            const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}", devMode: true };</script>`;
-            let htmlContent = content.toString();
-            const assetPrefix = mountPoint === "/" ? "/" : `${mountPoint}/`;
-            htmlContent = htmlContent.replace(/\/agents\//g, assetPrefix);
-            htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
-            content = Buffer.from(htmlContent);
+            content = Buffer.from(
+              injectUiConfigIntoHtml(content.toString(), mountPoint)
+            );
           }
           const mimeTypes = {
             ".html": "text/html",
@@ -6579,7 +6734,7 @@ async function loadBuilderVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path7__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -6809,7 +6964,7 @@ async function loadRegistryVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path7__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -6837,23 +6992,23 @@ async function loadRegistryVirtualModule(context) {
     const absPath = toAbsolutePath(importPath);
     return `    "${name}": async () => (await import("${absPath}")).default,`;
   }).join("\n");
-  const packedDir = path7__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
   const packedPackages = [];
-  if (fs7__default.existsSync(packedDir)) {
+  if (fs8__default.existsSync(packedDir)) {
     console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
     const packageDirs = discoverPackedPackageDirectories(packedDir);
     console.log(`[vite-plugin-agent] Found package dirs: ${packageDirs.join(", ")}`);
     for (const pkgPath of packageDirs) {
-      const pkgJsonPath = path7__default.join(pkgPath, "package.json");
-      if (fs7__default.existsSync(pkgJsonPath)) {
+      const pkgJsonPath = path8__default.join(pkgPath, "package.json");
+      if (fs8__default.existsSync(pkgJsonPath)) {
         try {
-          const pkgJson = JSON.parse(fs7__default.readFileSync(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(fs8__default.readFileSync(pkgJsonPath, "utf-8"));
           console.log(`[vite-plugin-agent] Loaded ${pkgPath} package.json, standardagent:`, pkgJson.standardagent);
           if (!pkgJson.standardagent) {
             continue;
           }
           const mainEntry = pkgJson.main || "./dist/index.js";
-          const outputDir = path7__default.dirname(mainEntry).replace(/^\.\//, "");
+          const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
           const pkg = {
             packageId: pkgJson.name,
             version: pkgJson.version,
@@ -6971,7 +7126,7 @@ export function getVisibleToolNames() {
 async function loadRoutesVirtualModule(context) {
   const { mountPoint, threadApiDir, rou3Code, hmr } = context;
   const threadRoutes = scanApiDirectory(threadApiDir);
-  const toAbsolutePath = (inputPath) => path7__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
+  const toAbsolutePath = (inputPath) => path8__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
   const threadRouteCode = threadRoutes.map(({ method, route, importPath }) => {
     const apiRoute = `/api/threads/:threadId${route}`;
     return `  addRoute(
@@ -6982,20 +7137,20 @@ async function loadRoutesVirtualModule(context) {
   );`;
   }).join("\n");
   const packedThreadRoutes = [];
-  const packedDir = path7__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
   const packedPackageDirs = discoverPackedPackageDirectories(packedDir);
   for (const packagePath of packedPackageDirs) {
-    const packageJsonPath = path7__default.join(packagePath, "package.json");
-    if (!fs7__default.existsSync(packageJsonPath)) {
+    const packageJsonPath = path8__default.join(packagePath, "package.json");
+    if (!fs8__default.existsSync(packageJsonPath)) {
       continue;
     }
     try {
-      const packageJson = JSON.parse(fs7__default.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs8__default.readFileSync(packageJsonPath, "utf-8"));
       if (!packageJson.standardagent) {
         continue;
       }
       const mainEntry = packageJson.main || "./dist/index.js";
-      const outputDir = path7__default.dirname(mainEntry).replace(/^\.\//, "");
+      const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
       const threadEndpoints = scanPackedThreadEndpoints(packagePath, outputDir);
       for (const endpoint of threadEndpoints) {
         const apiRoute = `/api/threads/:threadId${endpoint.route}`;
@@ -7035,12 +7190,19 @@ const MOUNT_POINT = "${mountPoint}";
 
 // Routes that don't require authentication
 const PUBLIC_ROUTES = [
+  '/api/auth/bootstrap',
   '/api/auth/login',
+  '/api/auth/bootstrap',
   '/api/auth/config',
+  '/api/config',
   '/api/auth/oauth/github',
   '/api/auth/oauth/google',
   '/api/auth/oauth/github/callback',
   '/api/auth/oauth/google/callback',
+  '/api/platform-auth/bootstrap',
+  '/api/platform-auth/login',
+  '/api/platform-auth/logout',
+  '/api/platform-auth/me',
   '/api/hooks'  // Hook metadata is safe to expose publicly
 ];
 
@@ -7061,6 +7223,20 @@ function isPublicRoute(routePath) {
     return true;
   }
 
+  // Platform proxy routes handle their own auth.
+  if (routePath.startsWith('/api/platform/') || routePath === '/api/platform') {
+    return true;
+  }
+
+  // Platform session proxy and auth bridge handle auth via platform cookies.
+  if (routePath.startsWith('/api/platform-session/') || routePath === '/api/platform-session') {
+    return true;
+  }
+
+  if (routePath.startsWith('/api/platform-auth/') || routePath === '/api/platform-auth') {
+    return true;
+  }
+
   return false;
 }
 
@@ -7325,12 +7501,12 @@ ${hooksCode}
 };`;
   }
   if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
-    const relativeToolsDir = path7__default.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
-    const relativeHooksDir = path7__default.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
-    const relativeApiDir = path7__default.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
-    const relativeModelsDir = path7__default.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
-    const relativePromptsDir = path7__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
-    const relativeAgentsDir = path7__default.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}",
@@ -7500,14 +7676,14 @@ var packingDeps = [
   "typescript"
 ];
 function createPluginViteConfig(pluginModuleUrl) {
-  const currentDir = path7__default.dirname(fileURLToPath(pluginModuleUrl));
+  const currentDir = path8__default.dirname(fileURLToPath(pluginModuleUrl));
   const isInDist = currentDir.endsWith("dist");
-  const builderClientDir = path7__default.resolve(
+  const builderClientDir = path8__default.resolve(
     currentDir,
     isInDist ? "./client" : "../dist/client"
   );
   return {
-    publicDir: fs7__default.existsSync(builderClientDir) ? builderClientDir : void 0,
+    publicDir: fs8__default.existsSync(builderClientDir) ? builderClientDir : void 0,
     build: {
       rollupOptions: {
         external: [...packingDeps]
@@ -7564,14 +7740,14 @@ function agentbuilder(options = {}) {
   if (mountPoint.endsWith("/") && mountPoint.length > 1) {
     mountPoint = mountPoint.slice(0, -1);
   }
-  const toolsDir = options.toolsDir ? path7__default.resolve(process.cwd(), options.toolsDir) : path7__default.resolve(process.cwd(), "agents/tools");
-  const hooksDir = options.hooksDir ? path7__default.resolve(process.cwd(), options.hooksDir) : path7__default.resolve(process.cwd(), "agents/hooks");
-  const threadApiDir = options.apiDir ? path7__default.resolve(process.cwd(), options.apiDir) : path7__default.resolve(process.cwd(), "agents/api");
-  const modelsDir = options.modelsDir ? path7__default.resolve(process.cwd(), options.modelsDir) : path7__default.resolve(process.cwd(), "agents/models");
-  const promptsDir = options.promptsDir ? path7__default.resolve(process.cwd(), options.promptsDir) : path7__default.resolve(process.cwd(), "agents/prompts");
-  const agentsDir = options.agentsDir ? path7__default.resolve(process.cwd(), options.agentsDir) : path7__default.resolve(process.cwd(), "agents/agents");
-  const effectsDir = options.effectsDir ? path7__default.resolve(process.cwd(), options.effectsDir) : path7__default.resolve(process.cwd(), "agents/effects");
-  const outputDir = path7__default.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 installedProviders = buildInstalledProviderCatalog(options.providers || []);
   const installedProviderPackageMap = buildProviderPackageMap(options.providers || []);
   const typeGenConfig = {
@@ -7588,11 +7764,11 @@ function agentbuilder(options = {}) {
     }
   }
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path7__default.dirname(__filename);
-  const rou3Path = path7__default.join(__dirname, "../dist/rou3.js");
+  const __dirname = path8__default.dirname(__filename);
+  const rou3Path = path8__default.join(__dirname, "../dist/rou3.js");
   let rou3Code = "";
   try {
-    rou3Code = fs7__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+    rou3Code = fs8__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);
   }
@@ -7702,28 +7878,28 @@ function agentbuilder(options = {}) {
     writeBundle(options2, bundle) {
       const outDir = options2.dir || "dist";
       const mountPath = mountPoint.slice(1);
-      const mountDir = mountPath ? path7__default.join(outDir, "../client", mountPath) : path7__default.join(outDir, "../client");
-      const currentDir = path7__default.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 = path7__default.resolve(
+      const clientDir = path8__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
-      if (!fs7__default.existsSync(clientDir)) {
+      if (!fs8__default.existsSync(clientDir)) {
         console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
         return;
       }
-      fs7__default.mkdirSync(mountDir, { recursive: true });
+      fs8__default.mkdirSync(mountDir, { recursive: true });
       function copyRecursive(src, dest) {
-        const entries = fs7__default.readdirSync(src, { withFileTypes: true });
+        const entries = fs8__default.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const srcPath = path7__default.join(src, entry.name);
-          const destPath = path7__default.join(dest, entry.name);
+          const srcPath = path8__default.join(src, entry.name);
+          const destPath = path8__default.join(dest, entry.name);
           if (entry.isDirectory()) {
-            fs7__default.mkdirSync(destPath, { recursive: true });
+            fs8__default.mkdirSync(destPath, { recursive: true });
             copyRecursive(srcPath, destPath);
           } else {
-            let content = fs7__default.readFileSync(srcPath);
+            let content = fs8__default.readFileSync(srcPath);
             if (entry.name === "index.html") {
               const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
               let htmlContent = content.toString();
@@ -7732,7 +7908,7 @@ function agentbuilder(options = {}) {
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs7__default.writeFileSync(destPath, content);
+            fs8__default.writeFileSync(destPath, content);
           }
         }
       }